diff --git a/Cargo.toml b/Cargo.toml
index 98d412b..3f4f333 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [package]
 name = "d20"
-version = "0.1.0"
+version = "0.1.1"
+edition = "2015"
 authors = ["Dan Nemeth <dan.nemeth@gmail.com>", "Kevin Hoffman <alothien@gmail.com>"]
 description = "A library for rolling dice based on simple expressions"
 license = "MPL-2.0"
diff --git a/src/lib.rs b/src/lib.rs
index bd0808c..42ae303 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -77,7 +77,7 @@
 extern crate rand;
 extern crate regex;
 
-use std::fmt;
+use std::{fmt, error::Error};
 use rand::{thread_rng, Rng};
 use regex::Regex;
 
@@ -184,15 +184,15 @@ pub enum DieRollTerm {
 
 
 impl DieRollTerm {
-    fn parse(drt: &str) -> DieRollTerm {
+    fn parse(drt: &str) -> Result<DieRollTerm, Box<dyn Error>> {
         if drt.to_lowercase().contains('d') {
             let v: Vec<&str> = drt.split("d").collect();
-            DieRollTerm::DieRoll {
-                multiplier: v[0].parse::<i8>().unwrap(),
-                sides: v[1].parse::<u8>().unwrap(),
-            }
+            Ok(DieRollTerm::DieRoll {
+                multiplier: v[0].parse::<i8>()?,
+                sides: v[1].parse::<u8>()?,
+            })
         } else {
-            DieRollTerm::Modifier(drt.parse::<i8>().unwrap())
+            Ok(DieRollTerm::Modifier(drt.parse::<i8>()?))
         }
     }
 
@@ -237,7 +237,10 @@ impl fmt::Display for DieRollTerm {
 /// text indicating why the function was unable to roll the dice / evaluate the expression.
 pub fn roll_dice<'a>(s: &'a str) -> Result<Roll, &'a str> {
     let s: String = s.split_whitespace().collect();
-    let terms: Vec<DieRollTerm> = parse_die_roll_terms(&s);
+    let terms: Vec<DieRollTerm> = match parse_die_roll_terms(&s) {
+        Ok(t) => t,
+        Err(_) => return Err("Invalid die roll expression: unable to parse terms."),
+    };
 
     if terms.len() == 0 {
         Err("Invalid die roll expression: no die roll terms found.")
@@ -254,16 +257,16 @@ pub fn roll_dice<'a>(s: &'a str) -> Result<Roll, &'a str> {
     }
 }
 
-fn parse_die_roll_terms(drex: &str) -> Vec<DieRollTerm> {
+fn parse_die_roll_terms(drex: &str) -> Result<Vec<DieRollTerm>, Box<dyn Error>> {
     let mut terms = Vec::new();
 
-    let re = Regex::new(r"([+-]?\s*\d+[dD]\d+|[+-]?\s*\d+)").unwrap();
+    let re = Regex::new(r"([+-]?\s*\d+[dD]\d+|[+-]?\s*\d+)")?;
 
     let matches = re.find_iter(drex);
     for m in matches {
-        terms.push(DieRollTerm::parse(&drex[m.start()..m.end()]));
+        terms.push(DieRollTerm::parse(&drex[m.start()..m.end()])?);
     }
-    terms
+    Ok(terms)
 }
 
 /// Generates a random number within the specified range. Returns a `Result` containing
diff --git a/src/tests.rs b/src/tests.rs
index e7557f3..37c8fe9 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -9,7 +9,7 @@ fn die_roll_expression_parsed() {
     let nd = "-4d10+5".to_string();
     let mf = "50+2d8-1d4".to_string();
 
-    let pv = parse_die_roll_terms(&pd);
+    let pv = parse_die_roll_terms(&pd).unwrap();
     if let DieRollTerm::DieRoll { multiplier: m, sides: s } = pv[0] {
         assert_eq!(m, 3);
         assert_eq!(s, 12);
@@ -18,7 +18,7 @@ fn die_roll_expression_parsed() {
         assert_eq!(n, 4);
     }
 
-    let nv = parse_die_roll_terms(&nd);
+    let nv = parse_die_roll_terms(&nd).unwrap();
     if let DieRollTerm::DieRoll { multiplier: m, sides: s } = nv[0] {
         assert_eq!(m, -4);
         assert_eq!(s, 10);
@@ -27,7 +27,7 @@ fn die_roll_expression_parsed() {
         assert_eq!(n, 5);
     }
 
-    let mv = parse_die_roll_terms(&mf);
+    let mv = parse_die_roll_terms(&mf).unwrap();
     if let DieRollTerm::Modifier(n) = mv[0] {
         assert_eq!(n, 50);
     }
@@ -46,8 +46,8 @@ fn die_roll_expression_parsed() {
 fn die_roll_term_parsed() {
     let drt = "3d6".to_string();
     let mfy = "+7".to_string();
-    let drt = DieRollTerm::parse(&drt);
-    let mfy = DieRollTerm::parse(&mfy);
+    let drt = DieRollTerm::parse(&drt).unwrap();
+    let mfy = DieRollTerm::parse(&mfy).unwrap();
     if let DieRollTerm::DieRoll { multiplier: m, sides: s } = drt {
         assert_eq!(m, 3);
         assert_eq!(s, 6);
@@ -64,10 +64,10 @@ fn die_roll_term_parsed() {
 
 #[test]
 fn die_roll_term_calculated() {
-    let dt = DieRollTerm::parse("6d1").evaluate();
-    let nt = DieRollTerm::parse("-4d1").evaluate();
-    let pm = DieRollTerm::parse("+7").evaluate();
-    let nm = DieRollTerm::parse("-7").evaluate();
+    let dt = DieRollTerm::parse("6d1").unwrap().evaluate();
+    let nt = DieRollTerm::parse("-4d1").unwrap().evaluate();
+    let pm = DieRollTerm::parse("+7").unwrap().evaluate();
+    let nm = DieRollTerm::parse("-7").unwrap().evaluate();
 
     let dtr = DieRollTerm::calculate(dt);
     assert_eq!(dtr, 6);
@@ -84,7 +84,7 @@ fn die_roll_term_calculated() {
 
 #[test]
 fn die_roll_term_evaluated() {
-    let drt = DieRollTerm::parse("3d1");
+    let drt = DieRollTerm::parse("3d1").unwrap();
     let v = drt.evaluate();
 
     assert_eq!(v.1.len(), 3);
@@ -95,8 +95,8 @@ fn die_roll_term_evaluated() {
 
 #[test]
 fn die_roll_term_modifier_evaluated() {
-    let mfy = DieRollTerm::parse("+7");
-    let mfy2 = DieRollTerm::parse("-7");
+    let mfy = DieRollTerm::parse("+7").unwrap();
+    let mfy2 = DieRollTerm::parse("-7").unwrap();
     let v1 = mfy.evaluate();
     let v2 = mfy2.evaluate();
 
@@ -172,9 +172,9 @@ fn iterator_yields_new_results() {
 
 #[test]
 fn die_roll_term_displays_properly() {
-    let drt = DieRollTerm::parse("3d6");
-    let pm = DieRollTerm::parse("5");
-    let nm = DieRollTerm::parse("-6");
+    let drt = DieRollTerm::parse("3d6").unwrap();
+    let pm = DieRollTerm::parse("5").unwrap();
+    let nm = DieRollTerm::parse("-6").unwrap();
 
     let out = format!("{}", drt);
     assert_eq!(out, "3d6");