diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index f5ea57f..f01ec85 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -304,10 +304,10 @@ impl fmt::Debug for SelectorList {
 
 impl fmt::Display for SelectorList {
     fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
-        r#try!(write!(w, "{}", self.head));
+        write!(w, "{}", self.head)?;
         if let Some(ref tok_vec) = self.tail {
             for t in tok_vec.iter() {
-                r#try!(write!(w, ".{}", t.fragment));
+                write!(w, ".{}", t.fragment)?;
             }
         }
         return Ok(());
@@ -795,37 +795,37 @@ impl fmt::Display for Expression {
     fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
         match self {
             &Expression::Simple(ref v) => {
-                r#try!(write!(w, "{}", v.to_string()));
+                write!(w, "{}", v.to_string())?;
             }
             &Expression::Binary(_) => {
-                r#try!(write!(w, "<Expr>"));
+                write!(w, "<Expr>")?;
             }
             &Expression::Compare(_) => {
-                r#try!(write!(w, "<Expr>"));
+                write!(w, "<Expr>")?;
             }
             &Expression::ListOp(_) => {
-                r#try!(write!(w, "<Expr>"));
+                write!(w, "<Expr>")?;
             }
             &Expression::Copy(_) => {
-                r#try!(write!(w, "<Copy>"));
+                write!(w, "<Copy>")?;
             }
             &Expression::Grouped(_) => {
-                r#try!(write!(w, "(<Expr>)"));
+                write!(w, "(<Expr>)")?;
             }
             &Expression::Format(_) => {
-                r#try!(write!(w, "<Format Expr>"));
+                write!(w, "<Format Expr>")?;
             }
             &Expression::Call(_) => {
-                r#try!(write!(w, "<MacroCall>"));
+                write!(w, "<MacroCall>")?;
             }
             &Expression::Macro(_) => {
-                r#try!(write!(w, "<Macro>"));
+                write!(w, "<Macro>")?;
             }
             &Expression::Module(_) => {
-                r#try!(write!(w, "<Module>"));
+                write!(w, "<Module>")?;
             }
             &Expression::Select(_) => {
-                r#try!(write!(w, "<Select>"));
+                write!(w, "<Select>")?;
             }
         }
         Ok(())
diff --git a/src/build/assets.rs b/src/build/assets.rs
index 22f00c1..862a9c0 100644
--- a/src/build/assets.rs
+++ b/src/build/assets.rs
@@ -51,17 +51,17 @@ impl MemoryCache {
 
 impl Cache for MemoryCache {
     fn has_path(&self, path: &PathBuf) -> Result<bool> {
-        let new_path = r#try!(path.canonicalize());
+        let new_path = path.canonicalize()?;
         Ok(self.map.contains_key(&new_path))
     }
 
     fn get(&self, path: &PathBuf) -> Result<Option<Rc<Val>>> {
-        let new_path = r#try!(path.canonicalize());
+        let new_path = path.canonicalize()?;
         Ok(self.map.get(&new_path).map(|v| v.clone()))
     }
 
     fn stash(&mut self, path: PathBuf, asset: Rc<Val>) -> Result<()> {
-        let new_path = r#try!(path.canonicalize());
+        let new_path = path.canonicalize()?;
         self.map.insert(new_path, asset);
         Ok(())
     }
diff --git a/src/build/ir.rs b/src/build/ir.rs
index a7a6089..3557f90 100644
--- a/src/build/ir.rs
+++ b/src/build/ir.rs
@@ -73,7 +73,7 @@ impl Val {
                     Ok(false)
                 } else {
                     for (i, lv) in ldef.iter().enumerate() {
-                        r#try!(lv.equal(rdef[i].as_ref(), pos.clone()));
+                        lv.equal(rdef[i].as_ref(), pos.clone())?;
                     }
                     Ok(true)
                 }
@@ -89,7 +89,7 @@ impl Val {
                             return Ok(false);
                         } else {
                             // field value equality.
-                            if !r#try!(lv.1.equal(field_target.1.as_ref(), lv.0.pos.clone())) {
+                            if !lv.1.equal(field_target.1.as_ref(), lv.0.pos.clone())? {
                                 return Ok(false);
                             }
                         }
@@ -190,25 +190,25 @@ impl Display for Val {
             &Val::Int(ref i) => write!(f, "Int({})", i),
             &Val::Str(ref s) => write!(f, "String({})", s),
             &Val::List(ref def) => {
-                r#try!(write!(f, "[\n"));
+                write!(f, "[\n")?;
                 for v in def.iter() {
-                    r#try!(write!(f, "\t{},\n", v));
+                    write!(f, "\t{},\n", v)?;
                 }
                 write!(f, "]")
             }
             &Val::Macro(_) => write!(f, "Macro(..)"),
             &Val::Module(_) => write!(f, "Module{{..}}"),
             &Val::Tuple(ref def) => {
-                r#try!(write!(f, "Tuple(\n"));
+                write!(f, "Tuple(\n")?;
                 for v in def.iter() {
-                    r#try!(write!(f, "\t{} = {},\n", v.0.val, v.1));
+                    write!(f, "\t{} = {},\n", v.0.val, v.1)?;
                 }
                 write!(f, ")")
             }
             &Val::Env(ref def) => {
-                r#try!(write!(f, "Env(\n"));
+                write!(f, "Env(\n")?;
                 for v in def.iter() {
-                    r#try!(write!(f, "\t{}=\"{}\"\n", v.0, v.1));
+                    write!(f, "\t{}=\"{}\"\n", v.0, v.1)?;
                 }
                 write!(f, ")")
             }
diff --git a/src/build/mod.rs b/src/build/mod.rs
index 79be32d..f98ddf4 100644
--- a/src/build/mod.rs
+++ b/src/build/mod.rs
@@ -72,7 +72,7 @@ impl MacroDef {
         for &(ref key, ref expr) in self.fields.iter() {
             // We clone the expressions here because this macro may be consumed
             // multiple times in the future.
-            let val = r#try!(b.eval_expr(expr));
+            let val = b.eval_expr(expr)?;
             result.push((key.into(), val.clone()));
         }
         Ok(result)
@@ -197,7 +197,7 @@ impl Builder {
     fn tuple_to_val(&mut self, fields: &Vec<(Token, Expression)>) -> Result<Rc<Val>, Box<Error>> {
         let mut new_fields = Vec::<(PositionedItem<String>, Rc<Val>)>::new();
         for &(ref name, ref expr) in fields.iter() {
-            let val = r#try!(self.eval_expr(expr));
+            let val = self.eval_expr(expr)?;
             new_fields.push((name.into(), val));
         }
         Ok(Rc::new(Val::Tuple(new_fields)))
@@ -206,7 +206,7 @@ impl Builder {
     fn list_to_val(&mut self, def: &ListDef) -> Result<Rc<Val>, Box<Error>> {
         let mut vals = Vec::new();
         for expr in def.elems.iter() {
-            vals.push(r#try!(self.eval_expr(expr)));
+            vals.push(self.eval_expr(expr)?);
         }
         Ok(Rc::new(Val::List(vals)))
     }
@@ -254,7 +254,7 @@ impl Builder {
     /// Builds a list of parsed UCG Statements.
     pub fn eval_stmts(&mut self, ast: &Vec<Statement>) -> BuildResult {
         for stmt in ast.iter() {
-            r#try!(self.eval_stmt(stmt));
+            self.eval_stmt(stmt)?;
         }
         Ok(())
     }
@@ -265,7 +265,7 @@ impl Builder {
                 //panic!("Successfully parsed {}", input);
                 let mut out: Option<Rc<Val>> = None;
                 for stmt in stmts.iter() {
-                    out = Some(r#try!(self.eval_stmt(stmt)));
+                    out = Some(self.eval_stmt(stmt)?);
                 }
                 match out {
                     None => return Ok(Rc::new(Val::Empty)),
@@ -287,9 +287,9 @@ impl Builder {
 
     /// Builds a ucg file at the named path.
     pub fn build(&mut self) -> BuildResult {
-        let mut f = r#try!(File::open(&self.file));
+        let mut f = File::open(&self.file)?;
         let mut s = String::new();
-        r#try!(f.read_to_string(&mut s));
+        f.read_to_string(&mut s)?;
         let eval_result = self.eval_string(&s);
         match eval_result {
             Ok(v) => {
@@ -340,7 +340,7 @@ impl Builder {
         } else {
             normalized = import_path;
         }
-        normalized = r#try!(normalized.canonicalize());
+        normalized = normalized.canonicalize()?;
         if self.detect_import_cycle(normalized.to_string_lossy().as_ref()) {
             return Err(Box::new(error::BuildError::new(
                 format!(
@@ -356,13 +356,13 @@ impl Builder {
         // Introduce a scope so the above borrow is dropped before we modify
         // the cache below.
         // Only parse the file once on import.
-        let maybe_asset = r#try!(self.assets.borrow().get(&normalized));
+        let maybe_asset = self.assets.borrow().get(&normalized)?;
         let result = match maybe_asset {
             Some(v) => v.clone(),
             None => {
                 let mut b = Self::new(normalized.clone(), self.assets.clone());
                 b.prepend_import_stack(&self.import_stack);
-                r#try!(b.build());
+                b.build()?;
                 b.get_outputs_as_val()
             }
         };
@@ -376,12 +376,12 @@ impl Builder {
         }
         self.build_output.insert(key, result.clone());
         let mut mut_assets_cache = self.assets.borrow_mut();
-        r#try!(mut_assets_cache.stash(normalized.clone(), result.clone()));
+        mut_assets_cache.stash(normalized.clone(), result.clone())?;
         return Ok(result);
     }
 
     fn eval_let(&mut self, def: &LetDef) -> Result<Rc<Val>, Box<Error>> {
-        let val = r#try!(self.eval_expr(&def.value));
+        let val = self.eval_expr(&def.value)?;
         let name = &def.name;
         // TODO(jwall): Enforce the reserved words list here.
         if Self::check_reserved_word(&name.fragment) {
@@ -421,7 +421,7 @@ impl Builder {
             // having a single builder per file.
             &Statement::Output(ref typ, ref expr) => {
                 if let None = self.out_lock {
-                    let val = r#try!(self.eval_expr(expr));
+                    let val = self.eval_expr(expr)?;
                     self.out_lock = Some((typ.fragment.to_string(), val.clone()));
                     Ok(val)
                 } else {
@@ -518,7 +518,7 @@ impl Builder {
         next: (&Position, &str),
         elems: &Vec<Rc<Val>>,
     ) -> Result<(), Box<Error>> {
-        let idx = r#try!(next.1.parse::<usize>());
+        let idx = next.1.parse::<usize>()?;
         if idx < elems.len() {
             stack.push_back(elems[idx].clone());
         } else {
@@ -537,7 +537,7 @@ impl Builder {
     }
 
     fn lookup_selector(&mut self, sl: &SelectorList) -> Result<Rc<Val>, Box<Error>> {
-        let first = r#try!(self.eval_expr(&sl.head));
+        let first = self.eval_expr(&sl.head)?;
         // First we ensure that the result is a tuple or a list.
         let mut stack = VecDeque::new();
         match first.as_ref() {
@@ -570,20 +570,20 @@ impl Builder {
                 let next = it.next().unwrap();
                 match vref.as_ref() {
                     &Val::Tuple(ref fs) => {
-                        r#try!(self.lookup_in_tuple(&mut stack, sl, (&next.pos, &next.fragment), fs));
+                        self.lookup_in_tuple(&mut stack, sl, (&next.pos, &next.fragment), fs)?;
                         continue;
                     }
                     &Val::Env(ref fs) => {
-                        r#try!(self.lookup_in_env(&next, &mut stack, fs));
+                        self.lookup_in_env(&next, &mut stack, fs)?;
                         continue;
                     }
                     &Val::List(ref elems) => {
-                        r#try!(self.lookup_in_list(
+                        self.lookup_in_list(
                             &mut stack,
                             sl,
                             (&next.pos, &next.fragment),
                             elems
-                        ));
+                        )?;
                         continue;
                     }
                     _ => {
@@ -737,9 +737,7 @@ impl Builder {
         left: Rc<Val>,
         right: Rc<Val>,
     ) -> Result<Rc<Val>, Box<Error>> {
-        Ok(Rc::new(Val::Boolean(r#try!(
-            left.equal(right.as_ref(), pos.clone())
-        ))))
+        Ok(Rc::new(Val::Boolean(left.equal(right.as_ref(), pos.clone())?)))
     }
 
     fn do_not_deep_equal(
@@ -748,9 +746,7 @@ impl Builder {
         left: Rc<Val>,
         right: Rc<Val>,
     ) -> Result<Rc<Val>, Box<Error>> {
-        Ok(Rc::new(Val::Boolean(!r#try!(
-            left.equal(right.as_ref(), pos.clone())
-        ))))
+        Ok(Rc::new(Val::Boolean(!left.equal(right.as_ref(), pos.clone())?)))
     }
 
     fn do_gt(&self, pos: &Position, left: Rc<Val>, right: Rc<Val>) -> Result<Rc<Val>, Box<Error>> {
@@ -855,8 +851,8 @@ impl Builder {
 
     fn eval_binary(&mut self, def: &BinaryOpDef) -> Result<Rc<Val>, Box<Error>> {
         let kind = &def.kind;
-        let left = r#try!(self.eval_expr(&def.left));
-        let right = r#try!(self.eval_expr(&def.right));
+        let left = self.eval_expr(&def.left)?;
+        let right = self.eval_expr(&def.right)?;
         match kind {
             &BinaryExprType::Add => self.add_vals(&def.pos, left, right),
             &BinaryExprType::Sub => self.subtract_vals(&def.pos, left, right),
@@ -867,8 +863,8 @@ impl Builder {
 
     fn eval_compare(&mut self, def: &ComparisonDef) -> Result<Rc<Val>, Box<Error>> {
         let kind = &def.kind;
-        let left = r#try!(self.eval_expr(&def.left));
-        let right = r#try!(self.eval_expr(&def.right));
+        let left = self.eval_expr(&def.left)?;
+        let right = self.eval_expr(&def.right)?;
         match kind {
             &CompareType::Equal => self.do_deep_equal(&def.pos, left, right),
             &CompareType::GT => self.do_gt(&def.pos, left, right),
@@ -937,7 +933,7 @@ impl Builder {
             }
         }
         for &(ref key, ref val) in overrides.iter() {
-            let expr_result = r#try!(self.eval_expr(val));
+            let expr_result = self.eval_expr(val)?;
             match m.entry(key.into()) {
                 // brand new field here.
                 Entry::Vacant(v) => {
@@ -990,7 +986,7 @@ impl Builder {
     }
 
     fn eval_copy(&mut self, def: &CopyDef) -> Result<Rc<Val>, Box<Error>> {
-        let v = r#try!(self.lookup_selector(&def.selector.sel));
+        let v = self.lookup_selector(&def.selector.sel)?;
         if let &Val::Tuple(ref src_fields) = v.as_ref() {
             self.push_val(v.clone());
             return self.copy_from_base(&src_fields, &def.fields);
@@ -1006,7 +1002,7 @@ impl Builder {
                 // Push our base tuple on the stack so the copy can use
                 // self to reference it.
                 b.push_val(maybe_tpl.clone());
-                let mod_args = r#try!(self.copy_from_base(src_fields, &def.fields));
+                let mod_args = self.copy_from_base(src_fields, &def.fields)?;
                 // put our copied parameters tuple in our builder under the mod key.
                 let mod_key =
                     PositionedItem::new_with_pos(String::from("mod"), Position::new(0, 0, 0));
@@ -1028,7 +1024,7 @@ impl Builder {
                     }
                 }
                 // 4. Evaluate all the statements using the builder.
-                r#try!(b.eval_stmts(&mod_def.statements));
+                b.eval_stmts(&mod_def.statements)?;
                 // 5. Take all of the bindings in the module and construct a new
                 //    tuple using them.
                 return Ok(b.get_outputs_as_val());
@@ -1055,30 +1051,30 @@ impl Builder {
         let args = &def.args;
         let mut vals = Vec::new();
         for v in args.iter() {
-            let rcv = r#try!(self.eval_expr(v));
+            let rcv = self.eval_expr(v)?;
             vals.push(rcv.deref().clone());
         }
         let formatter = format::Formatter::new(tmpl.clone(), vals);
-        Ok(Rc::new(Val::Str(r#try!(formatter.render(&def.pos)))))
+        Ok(Rc::new(Val::Str(formatter.render(&def.pos)?)))
     }
 
     // FIXME(jwall): Handle module calls as well?
     fn eval_call(&mut self, def: &CallDef) -> Result<Rc<Val>, Box<Error>> {
         let sel = &def.macroref;
         let args = &def.arglist;
-        let v = r#try!(self.lookup_selector(&sel.sel));
+        let v = self.lookup_selector(&sel.sel)?;
         if let &Val::Macro(ref m) = v.deref() {
             // Congratulations this is actually a macro.
             let mut argvals: Vec<Rc<Val>> = Vec::new();
             for arg in args.iter() {
-                argvals.push(r#try!(self.eval_expr(arg)));
+                argvals.push(self.eval_expr(arg)?);
             }
-            let fields = r#try!(m.eval(
+            let fields = m.eval(
                 self.file.clone(),
                 self.assets.clone(),
                 self.env.clone(),
                 argvals
-            ));
+            )?;
             return Ok(Rc::new(Val::Tuple(fields)));
         }
         Err(Box::new(error::BuildError::new(
@@ -1121,7 +1117,7 @@ impl Builder {
         // First we rewrite the imports to be absolute paths.
         def.imports_to_absolute(root);
         // Then we create our tuple default.
-        def.arg_tuple = Some(r#try!(self.tuple_to_val(&def.arg_set)));
+        def.arg_tuple = Some(self.tuple_to_val(&def.arg_set)?);
         // Then we construct a new Val::Module
         Ok(Rc::new(Val::Module(def)))
     }
@@ -1131,7 +1127,7 @@ impl Builder {
         let def_expr = &def.default;
         let fields = &def.tuple;
         // First resolve the target expression.
-        let v = r#try!(self.eval_expr(target));
+        let v = self.eval_expr(target)?;
         // Second ensure that the expression resolves to a string.
         if let &Val::Str(ref name) = v.deref() {
             // Third find the field with that name in the tuple.
@@ -1168,7 +1164,7 @@ impl Builder {
     }
 
     fn eval_list_op(&mut self, def: &ListOpDef) -> Result<Rc<Val>, Box<Error>> {
-        let maybe_list = r#try!(self.eval_expr(&def.target));
+        let maybe_list = self.eval_expr(&def.target)?;
         let l = match maybe_list.as_ref() {
             &Val::List(ref elems) => elems,
             other => {
@@ -1180,16 +1176,16 @@ impl Builder {
             }
         };
         let mac = &def.mac;
-        if let &Val::Macro(ref macdef) = r#try!(self.lookup_selector(&mac.sel)).as_ref() {
+        if let &Val::Macro(ref macdef) = self.lookup_selector(&mac.sel)?.as_ref() {
             let mut out = Vec::new();
             for item in l.iter() {
                 let argvals = vec![item.clone()];
-                let fields = r#try!(macdef.eval(
+                let fields = macdef.eval(
                     self.file.clone(),
                     self.assets.clone(),
                     self.env.clone(),
                     argvals
-                ));
+                )?;
                 if let Some(v) = Self::find_in_fieldlist(&def.field, &fields) {
                     match def.typ {
                         ListOpType::Map => {
diff --git a/src/convert/env.rs b/src/convert/env.rs
index 446725f..509967f 100644
--- a/src/convert/env.rs
+++ b/src/convert/env.rs
@@ -43,8 +43,8 @@ impl EnvConverter {
                 eprintln!("Skipping empty variable: {}", name);
                 return Ok(());
             }
-            r#try!(write!(w, "{}=", name.val));
-            r#try!(self.write(&val, w));
+            write!(w, "{}=", name.val)?;
+            self.write(&val, w)?;
         }
         Ok(())
     }
@@ -61,22 +61,22 @@ impl EnvConverter {
                 return Ok(());
             }
             &Val::Boolean(b) => {
-                r#try!(write!(w, "{}\n", if b { "true" } else { "false" }));
+                write!(w, "{}\n", if b { "true" } else { "false" })?;
             }
             &Val::Float(ref f) => {
-                r#try!(write!(w, "{}\n", f));
+                write!(w, "{}\n", f)?;
             }
             &Val::Int(ref i) => {
-                r#try!(write!(w, "{}\n", i));
+                write!(w, "{}\n", i)?;
             }
             &Val::Str(ref s) => {
-                r#try!(write!(w, "'{}'\n", s));
+                write!(w, "'{}'\n", s)?;
             }
             &Val::List(ref items) => {
-                r#try!(self.convert_list(items, w));
+                self.convert_list(items, w)?;
             }
             &Val::Tuple(ref flds) => {
-                r#try!(self.convert_tuple(flds, w));
+                self.convert_tuple(flds, w)?;
             }
             &Val::Macro(ref _def) => {
                 // This is ignored
diff --git a/src/convert/exec.rs b/src/convert/exec.rs
index 3ac2124..bc7ade2 100644
--- a/src/convert/exec.rs
+++ b/src/convert/exec.rs
@@ -121,16 +121,16 @@ impl ExecConverter {
             // Okay if we have made it this far then we are ready to start creating our script.
             let mut script = Cursor::new(vec![]);
             // 1. First the script prefix line.
-            r#try!(write!(script, "#!/usr/bin/env bash\n"));
+            write!(script, "#!/usr/bin/env bash\n")?;
             // 2. then some initial setup. for bash hygiene.
-            r#try!(write!(script, "# Turn on unofficial Bash-Strict-Mode\n"));
-            r#try!(write!(script, "set -euo pipefail\n"));
+            write!(script, "# Turn on unofficial Bash-Strict-Mode\n")?;
+            write!(script, "set -euo pipefail\n")?;
             // 3. Then assign our environment variables
             if let Some(env_list) = env {
                 for &(ref name, ref v) in env_list.iter() {
                     // We only allow string fields in our env tuple.
                     if let &Val::Str(ref s) = v.as_ref() {
-                        r#try!(write!(script, "{}=\"{}\"\n", name.val, s));
+                        write!(script, "{}=\"{}\"\n", name.val, s)?;
                         continue;
                     }
                     return Err(Box::new(BuildError::new(
@@ -140,19 +140,19 @@ impl ExecConverter {
                     )));
                 }
             }
-            r#try!(write!(script, "\n"));
+            write!(script, "\n")?;
             // TODO(jwall): Should Flag converter have a strict mode?
             let flag_converter = convert::flags::FlagConverter::new();
             // 4. Then construct our command line. (be sure to use exec)
-            r#try!(write!(script, "exec {} ", command.unwrap()));
+            write!(script, "exec {} ", command.unwrap())?;
             if let Some(arg_list) = args {
                 for v in arg_list.iter() {
                     // We only allow tuples or strings in our args list.
                     match v.as_ref() {
                         &Val::Str(ref s) => {
-                            r#try!(write!(script, "{} ", s));
+                            write!(script, "{} ", s)?;
                         }
-                        &Val::Tuple(_) => r#try!(flag_converter.convert(v.clone(), &mut script)),
+                        &Val::Tuple(_) => flag_converter.convert(v.clone(), &mut script)?,
                         _ => {
                             return Err(Box::new(BuildError::new(
                                 "Exec args must be a list of strings or tuples of strings.",
@@ -166,7 +166,7 @@ impl ExecConverter {
             // Put cursor to the beginning of our script so when we copy
             // we copy the whole thing.
             script.set_position(0);
-            r#try!(std::io::copy(&mut script, w));
+            std::io::copy(&mut script, w)?;
             return Ok(());
         }
 
diff --git a/src/convert/flags.rs b/src/convert/flags.rs
index 6d7396c..94bc4f5 100644
--- a/src/convert/flags.rs
+++ b/src/convert/flags.rs
@@ -30,9 +30,9 @@ impl FlagConverter {
 
     fn write_flag_name(&self, pfx: &str, name: &str, w: &mut Write) -> Result {
         if name.chars().count() > 1 || pfx.chars().count() > 0 {
-            r#try!(write!(w, "--{}{} ", pfx, name));
+            write!(w, "--{}{} ", pfx, name)?;
         } else {
-            r#try!(write!(w, "-{} ", name));
+            write!(w, "-{} ", name)?;
         }
         return Ok(());
     }
@@ -47,8 +47,8 @@ impl FlagConverter {
                     pfx, name
                 );
             } else {
-                r#try!(self.write_flag_name(pfx, name, w));
-                r#try!(self.write(pfx, vref, w));
+                self.write_flag_name(pfx, name, w)?;
+                self.write(pfx, vref, w)?;
             }
         }
         return Ok(());
@@ -61,36 +61,36 @@ impl FlagConverter {
                 return Ok(());
             }
             &Val::Boolean(b) => {
-                r#try!(write!(w, "{} ", if b { "true" } else { "false" }));
+                write!(w, "{} ", if b { "true" } else { "false" })?;
             }
             &Val::Float(ref f) => {
-                r#try!(write!(w, "{} ", f));
+                write!(w, "{} ", f)?;
             }
             &Val::Int(ref i) => {
-                r#try!(write!(w, "{} ", i));
+                write!(w, "{} ", i)?;
             }
             &Val::Str(ref s) => {
-                r#try!(write!(w, "'{}' ", s));
+                write!(w, "'{}' ", s)?;
             }
             &Val::List(ref _def) => {
                 eprintln!("Skipping List...");
             }
             &Val::Tuple(ref flds) => for &(ref name, ref val) in flds.iter() {
                 if let &Val::Empty = val.as_ref() {
-                    r#try!(self.write_flag_name(pfx, &name.val, w));
+                    self.write_flag_name(pfx, &name.val, w)?;
                     continue;
                 }
                 match val.as_ref() {
                     &Val::Tuple(_) => {
                         let new_pfx = format!("{}{}.", pfx, name);
-                        r#try!(self.write(&new_pfx, val, w));
+                        self.write(&new_pfx, val, w)?;
                     }
                     &Val::List(ref def) => {
-                        r#try!(self.write_list_flag(pfx, &name.val, def, w));
+                        self.write_list_flag(pfx, &name.val, def, w)?;
                     }
                     _ => {
-                        r#try!(self.write_flag_name(pfx, &name.val, w));
-                        r#try!(self.write(pfx, &val, w));
+                        self.write_flag_name(pfx, &name.val, w)?;
+                        self.write(pfx, &val, w)?;
                     }
                 }
             },
diff --git a/src/convert/json.rs b/src/convert/json.rs
index bbfc94b..0ebf69b 100644
--- a/src/convert/json.rs
+++ b/src/convert/json.rs
@@ -29,7 +29,7 @@ impl JsonConverter {
     fn convert_list(&self, items: &Vec<Rc<Val>>) -> std::io::Result<serde_json::Value> {
         let mut v = Vec::new();
         for val in items.iter() {
-            v.push(r#try!(self.convert_value(val)));
+            v.push(self.convert_value(val)?);
         }
         Ok(serde_json::Value::Array(v))
     }
@@ -41,7 +41,7 @@ impl JsonConverter {
         let mut mp = serde_json::Map::new();
         for &(ref k, ref v) in items.iter() {
             mp.entry(k.val.clone())
-                .or_insert(r#try!(self.convert_value(v)));
+                .or_insert(self.convert_value(v)?);
         }
         Ok(serde_json::Value::Object(mp))
     }
@@ -84,16 +84,16 @@ impl JsonConverter {
                 eprintln!("Skipping module encoding as null...");
                 serde_json::Value::Null
             }
-            &Val::Env(ref fs) => r#try!(self.convert_env(fs)),
-            &Val::List(ref l) => r#try!(self.convert_list(l)),
-            &Val::Tuple(ref t) => r#try!(self.convert_tuple(t)),
+            &Val::Env(ref fs) => self.convert_env(fs)?,
+            &Val::List(ref l) => self.convert_list(l)?,
+            &Val::Tuple(ref t) => self.convert_tuple(t)?,
         };
         Ok(jsn_val)
     }
 
     fn write(&self, v: &Val, w: &mut Write) -> Result {
-        let jsn_val = r#try!(self.convert_value(v));
-        r#try!(serde_json::to_writer_pretty(w, &jsn_val));
+        let jsn_val = self.convert_value(v)?;
+        serde_json::to_writer_pretty(w, &jsn_val)?;
         Ok(())
     }
 }
diff --git a/src/convert/toml.rs b/src/convert/toml.rs
index c0b1aaf..261deba 100644
--- a/src/convert/toml.rs
+++ b/src/convert/toml.rs
@@ -36,7 +36,7 @@ impl TomlConverter {
     fn convert_list(&self, items: &Vec<Rc<Val>>) -> ConvertResult {
         let mut v = Vec::new();
         for val in items.iter() {
-            v.push(r#try!(self.convert_value(val)));
+            v.push(self.convert_value(val)?);
         }
         Ok(toml::Value::Array(v))
     }
@@ -45,7 +45,7 @@ impl TomlConverter {
         let mut mp = toml::value::Table::new();
         for &(ref k, ref v) in items.iter() {
             mp.entry(k.val.clone())
-                .or_insert(r#try!(self.convert_value(v)));
+                .or_insert(self.convert_value(v)?);
         }
         Ok(toml::Value::Table(mp))
     }
@@ -78,17 +78,17 @@ impl TomlConverter {
                 let err = SimpleError::new("Modules are not allowed in Toml Conversions!");
                 return Err(Box::new(err));
             }
-            &Val::Env(ref fs) => r#try!(self.convert_env(fs)),
-            &Val::List(ref l) => r#try!(self.convert_list(l)),
-            &Val::Tuple(ref t) => r#try!(self.convert_tuple(t)),
+            &Val::Env(ref fs) => self.convert_env(fs)?,
+            &Val::List(ref l) => self.convert_list(l)?,
+            &Val::Tuple(ref t) => self.convert_tuple(t)?,
         };
         Ok(toml_val)
     }
 
     fn write(&self, v: &Val, w: &mut Write) -> Result {
-        let toml_val = r#try!(self.convert_value(v));
-        let toml_bytes = r#try!(toml::ser::to_string_pretty(&toml_val));
-        r#try!(write!(w, "{}", toml_bytes));
+        let toml_val = self.convert_value(v)?;
+        let toml_bytes = toml::ser::to_string_pretty(&toml_val)?;
+        write!(w, "{}", toml_bytes)?;
         Ok(())
     }
 }
diff --git a/src/convert/yaml.rs b/src/convert/yaml.rs
index 0f5597f..94142b7 100644
--- a/src/convert/yaml.rs
+++ b/src/convert/yaml.rs
@@ -18,7 +18,7 @@ impl YamlConverter {
     fn convert_list(&self, items: &Vec<Rc<Val>>) -> std::io::Result<serde_yaml::Value> {
         let mut v = Vec::new();
         for val in items.iter() {
-            v.push(r#try!(self.convert_value(val)));
+            v.push(self.convert_value(val)?);
         }
         Ok(serde_yaml::Value::Sequence(v))
     }
@@ -42,7 +42,7 @@ impl YamlConverter {
         for &(ref k, ref v) in items.iter() {
             mapping.insert(
                 serde_yaml::Value::String(k.val.clone()),
-                r#try!(self.convert_value(v)),
+                self.convert_value(v)?,
             );
         }
         Ok(serde_yaml::Value::Mapping(mapping))
@@ -69,16 +69,16 @@ impl YamlConverter {
                 eprintln!("Skipping module encoding as null...");
                 serde_yaml::Value::Null
             }
-            &Val::Env(ref fs) => r#try!(self.convert_env(fs)),
-            &Val::List(ref l) => r#try!(self.convert_list(l)),
-            &Val::Tuple(ref t) => r#try!(self.convert_tuple(t)),
+            &Val::Env(ref fs) => self.convert_env(fs)?,
+            &Val::List(ref l) => self.convert_list(l)?,
+            &Val::Tuple(ref t) => self.convert_tuple(t)?,
         };
         Ok(yaml_val)
     }
 
     fn write(&self, v: &Val, w: &mut Write) -> Result {
-        let jsn_val = r#try!(self.convert_value(v));
-        r#try!(serde_yaml::to_writer(w, &jsn_val));
+        let jsn_val = self.convert_value(v)?;
+        serde_yaml::to_writer(w, &jsn_val)?;
         Ok(())
     }
 }
diff --git a/src/error.rs b/src/error.rs
index ba9ec3c..7013154 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -73,11 +73,11 @@ impl BuildError {
     }
 
     fn render(&self, w: &mut fmt::Formatter) -> fmt::Result {
-        r#try!(write!(
+        write!(
             w,
             "{} at line: {} column: {}\nCaused By:\n\t{} ",
             self.err_type, self.pos.line, self.pos.column, self.msg
-        ));
+        )?;
         Ok(())
     }
 }
@@ -118,18 +118,18 @@ where
                 None => break,
                 Some(err) => {
                     let context = err.get_context();
-                    r#try!(write!(
+                    write!(
                         w,
                         "{}{}: line: {}, column: {}\n",
                         tabstop,
                         err.get_msg(),
                         context.line(),
                         context.column(),
-                    ));
+                    )?;
                     tabstop = "\t";
                     curr_err = err.get_cause();
                     if curr_err.is_some() {
-                        r#try!(write!(w, "Caused by: \n"));
+                        write!(w, "Caused by: \n")?;
                     }
                 }
             }
diff --git a/src/main.rs b/src/main.rs
index 5f6dafc..f1dd6ed 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -65,7 +65,7 @@ fn run_converter(c: &traits::Converter, v: Rc<Val>, f: Option<&str>) -> traits::
             let mut path_buf = PathBuf::from(f);
             path_buf.set_extension(c.file_ext());
             let new_path = path_buf.to_str().unwrap();
-            Box::new(r#try!(File::create(&new_path)))
+            Box::new(File::create(&new_path)?)
         }
         None => Box::new(io::stdout()),
     };
@@ -87,7 +87,7 @@ fn build_file(
     if validate {
         builder.enable_validate_mode();
     }
-    r#try!(builder.build());
+    builder.build()?;
     if validate {
         println!("{}", builder.assert_collector.summary);
     }
@@ -160,7 +160,7 @@ fn visit_ucg_files(
     // TODO(jwall): Report the failing files at the bottom.
     let mut summary = String::new();
     if path.is_dir() {
-        let mut dir_iter = r#try!(std::fs::read_dir(path)).peekable();
+        let mut dir_iter = std::fs::read_dir(path)?.peekable();
         loop {
             let entry = match dir_iter.next() {
                 Some(e) => e,
@@ -168,7 +168,7 @@ fn visit_ucg_files(
                     break;
                 }
             };
-            let next_item = r#try!(entry);
+            let next_item = entry?;
             let next_path = next_item.path();
             let path_as_string = String::from(next_path.to_string_lossy());
             if next_path.is_dir() && recurse {