Suggest disambiguation for tons

src/conversions.rs

@@ -64,6 +64,16 @@ fn get_conversion(unit: NonMetric) -> Conversion {
 			from: pound_from,
 			to: MetricQuantity { amount: 14.0 * pound_to, unit: Metric::Gram },
 		},
+		NonMetric::ShortTon => Conversion {
+			offset: 0.0,
+			from: pound_from,
+			to: MetricQuantity { amount: 2000.0 * pound_to, unit: Metric::Gram },
+		},
+		NonMetric::LongTon => Conversion {
+			offset: 0.0,
+			from: pound_from,
+			to: MetricQuantity { amount: 2240.0 * pound_to, unit: Metric::Gram },
+		},
 		// Temperature
 		NonMetric::Fahrenheit => Conversion {
 			offset: 32.0,
@@ -184,6 +194,8 @@ mod test {
 			Test(NonMetric::Ounce, 28.349523125),
 			Test(NonMetric::Pound, 453.59237),
 			Test(NonMetric::Stone, 6350.29318),
+			Test(NonMetric::ShortTon, 907184.74),
+			Test(NonMetric::LongTon, 1016046.9088),
 		];
 		run_tests(&tests, Metric::Gram);
 	}

src/lib.rs

@@ -77,6 +77,8 @@ fn unit_to_name(unit: NonMetric) -> &'static str {
 		NonMetric::Ounce => "ounces",
 		NonMetric::Pound => "pounds",
 		NonMetric::Stone => "stones",
+		NonMetric::ShortTon => "short tons",
+		NonMetric::LongTon => "long tons",
 		// Temperature
 		NonMetric::Fahrenheit => "degrees Fahrenheit",
 		// Area
@@ -129,6 +131,8 @@ mod test {
 		assert_eq!(run("1 oz"), Ok("28.35 g".to_string()));
 		assert_eq!(run("1 lb"), Ok("453.6 g".to_string()));
 		assert_eq!(run("1 st"), Ok("6.35 kg".to_string()));
+		assert_eq!(run("1 short ton"), Ok("907.2 kg".to_string()));
+		assert_eq!(run("1 long ton"), Ok("1 016 kg".to_string()));
 		// Temperature
 		assert_eq!(run("-40 °F"), Ok("-40 °C".to_string()));
 		assert_eq!(run("0 °F"), Ok("-17.78 °C".to_string()));

src/parse.rs

@@ -98,6 +98,20 @@ fn parse_unit(input: String) -> Result<NonMetric, ParseError> {
 		"stones" => Ok(NonMetric::Stone),
 		"st" => Ok(NonMetric::Stone),
 
+		"short ton" => Ok(NonMetric::ShortTon),
+		"short tons" => Ok(NonMetric::ShortTon),
+		"US ton" => Ok(NonMetric::ShortTon),
+		"US tons" => Ok(NonMetric::ShortTon),
+		"us ton" => Ok(NonMetric::ShortTon),
+		"us tons" => Ok(NonMetric::ShortTon),
+
+		"long ton" => Ok(NonMetric::LongTon),
+		"long tons" => Ok(NonMetric::LongTon),
+		"imperial ton" => Ok(NonMetric::LongTon),
+		"imperial tons" => Ok(NonMetric::LongTon),
+		"imp ton" => Ok(NonMetric::LongTon),
+		"imp tons" => Ok(NonMetric::LongTon),
+
 		// Temperature
 		"degree Fahrenheit" => Ok(NonMetric::Fahrenheit),
 		"degrees Fahrenheit" => Ok(NonMetric::Fahrenheit),
@@ -282,6 +296,9 @@ fn parse_unit(input: String) -> Result<NonMetric, ParseError> {
 		"us gal" => Ok(NonMetric::USGallon),
 
 		// Ambiguous units
+		"ton" => Err(ParseError::AmbiguousUnit(input, "short", "long")),
+		"tons" => Err(ParseError::AmbiguousUnit(input, "short", "long")),
+
 		"fluid ounce" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
 		"fluid ounces" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
 		"fl oz" => Err(ParseError::AmbiguousUnit(input, "imp", "US")),
@@ -413,325 +430,346 @@ mod test {
 	#[test]
 	fn units() {
 		// Length
-		assert_eq!(parse_unit("inch".to_string()), Ok(NonMetric::Inch));
+		test_units(NonMetric::Inch, &[
-		assert_eq!(parse_unit("inches".to_string()), Ok(NonMetric::Inch));
+			"inch",
-		assert_eq!(parse_unit("in".to_string()), Ok(NonMetric::Inch));
+			"inches",
-		assert_eq!(parse_unit("\"".to_string()), Ok(NonMetric::Inch));
+			"in",
-		assert_eq!(parse_unit("″".to_string()), Ok(NonMetric::Inch));
+			"\"",
+			"″",
+		]);
 
-		assert_eq!(parse_unit("foot".to_string()), Ok(NonMetric::Foot));
+		test_units(NonMetric::Foot, &[
-		assert_eq!(parse_unit("feet".to_string()), Ok(NonMetric::Foot));
+			"foot",
-		assert_eq!(parse_unit("ft".to_string()), Ok(NonMetric::Foot));
+			"feet",
-		assert_eq!(parse_unit("'".to_string()), Ok(NonMetric::Foot));
+			"ft",
-		assert_eq!(parse_unit("′".to_string()), Ok(NonMetric::Foot));
+			"'",
+			"′",
+		]);
 
-		assert_eq!(parse_unit("yard".to_string()), Ok(NonMetric::Yard));
+		test_units(NonMetric::Yard, &[
-		assert_eq!(parse_unit("yards".to_string()), Ok(NonMetric::Yard));
+			"yard",
-		assert_eq!(parse_unit("yd".to_string()), Ok(NonMetric::Yard));
+			"yards",
+			"yd",
+		]);
 
-		assert_eq!(parse_unit("mile".to_string()), Ok(NonMetric::Mile));
+		test_units(NonMetric::Mile, &[
-		assert_eq!(parse_unit("miles".to_string()), Ok(NonMetric::Mile));
+			"mile",
-		assert_eq!(parse_unit("mi".to_string()), Ok(NonMetric::Mile));
+			"miles",
-		assert_eq!(parse_unit("m".to_string()), Ok(NonMetric::Mile));
+			"mi",
+			"m",
+		]);
 
 		// Weight
-		assert_eq!(parse_unit("ounce".to_string()), Ok(NonMetric::Ounce));
+		test_units(NonMetric::Ounce, &[
-		assert_eq!(parse_unit("ounces".to_string()), Ok(NonMetric::Ounce));
+			"ounce",
-		assert_eq!(parse_unit("oz".to_string()), Ok(NonMetric::Ounce));
+			"ounces",
+			"oz",
+		]);
 
-		assert_eq!(parse_unit("pound".to_string()), Ok(NonMetric::Pound));
+		test_units(NonMetric::Pound, &[
-		assert_eq!(parse_unit("pounds".to_string()), Ok(NonMetric::Pound));
+			"pound",
-		assert_eq!(parse_unit("lb".to_string()), Ok(NonMetric::Pound));
+			"pounds",
-		assert_eq!(parse_unit("lbs".to_string()), Ok(NonMetric::Pound));
+			"lb",
-		assert_eq!(parse_unit("#".to_string()), Ok(NonMetric::Pound));
+			"lbs",
+			"#",
+		]);
 
-		assert_eq!(parse_unit("stone".to_string()), Ok(NonMetric::Stone));
+		test_units(NonMetric::Stone, &[
-		assert_eq!(parse_unit("stones".to_string()), Ok(NonMetric::Stone));
+			"stone",
-		assert_eq!(parse_unit("st".to_string()), Ok(NonMetric::Stone));
+			"stones",
+			"st",
+		]);
+
+		test_units(NonMetric::ShortTon, &[
+			"short ton",
+			"short tons",
+			"US ton",
+			"US tons",
+			"us ton",
+			"us tons",
+		]);
+
+		test_units(NonMetric::LongTon, &[
+			"long ton",
+			"long tons",
+			"imperial ton",
+			"imperial tons",
+			"imp ton",
+			"imp tons",
+		]);
 
 		// Temperature
-		assert_eq!(parse_unit("degree Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
+		test_units(NonMetric::Fahrenheit, &[
-		assert_eq!(parse_unit("degrees Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
+			"degree Fahrenheit",
-		assert_eq!(parse_unit("degree fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
+			"degrees Fahrenheit",
-		assert_eq!(parse_unit("degrees fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
+			"degree fahrenheit",
-		assert_eq!(parse_unit("Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
+			"degrees fahrenheit",
-		assert_eq!(parse_unit("fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
+			"Fahrenheit",
-		assert_eq!(parse_unit("°F".to_string()), Ok(NonMetric::Fahrenheit));
+			"fahrenheit",
-		assert_eq!(parse_unit("F".to_string()), Ok(NonMetric::Fahrenheit));
+			"°F",
+			"F",
+		]);
 
 		// Area
-		assert_eq!(parse_unit("square inch".to_string()), Ok(NonMetric::SquareInch));
+		test_units(NonMetric::SquareInch, &[
-		assert_eq!(parse_unit("square inches".to_string()), Ok(NonMetric::SquareInch));
+			"square inch",
-		assert_eq!(parse_unit("square in".to_string()), Ok(NonMetric::SquareInch));
+			"square inches",
-		assert_eq!(parse_unit("sq inch".to_string()), Ok(NonMetric::SquareInch));
+			"square in",
-		assert_eq!(parse_unit("sq inches".to_string()), Ok(NonMetric::SquareInch));
+			"sq inch",
-		assert_eq!(parse_unit("sq in".to_string()), Ok(NonMetric::SquareInch));
+			"sq inches",
-		assert_eq!(parse_unit("inch²".to_string()), Ok(NonMetric::SquareInch));
+			"sq in",
-		assert_eq!(parse_unit("inches²".to_string()), Ok(NonMetric::SquareInch));
+			"inch²",
-		assert_eq!(parse_unit("in²".to_string()), Ok(NonMetric::SquareInch));
+			"inches²",
-		assert_eq!(parse_unit("\"²".to_string()), Ok(NonMetric::SquareInch));
+			"in²",
-		assert_eq!(parse_unit("″²".to_string()), Ok(NonMetric::SquareInch));
+			"\"²",
-		assert_eq!(parse_unit("inch^2".to_string()), Ok(NonMetric::SquareInch));
+			"″²",
-		assert_eq!(parse_unit("inches^2".to_string()), Ok(NonMetric::SquareInch));
+			"inch^2",
-		assert_eq!(parse_unit("in^2".to_string()), Ok(NonMetric::SquareInch));
+			"inches^2",
-		assert_eq!(parse_unit("\"^2".to_string()), Ok(NonMetric::SquareInch));
+			"in^2",
+			"\"^2",
+		]);
 
-		assert_eq!(parse_unit("square foot".to_string()), Ok(NonMetric::SquareFoot));
+		test_units(NonMetric::SquareFoot, &[
-		assert_eq!(parse_unit("square feet".to_string()), Ok(NonMetric::SquareFoot));
+			"square foot",
-		assert_eq!(parse_unit("square ft".to_string()), Ok(NonMetric::SquareFoot));
+			"square feet",
-		assert_eq!(parse_unit("sq foot".to_string()), Ok(NonMetric::SquareFoot));
+			"square ft",
-		assert_eq!(parse_unit("sq feet".to_string()), Ok(NonMetric::SquareFoot));
+			"sq foot",
-		assert_eq!(parse_unit("sq ft".to_string()), Ok(NonMetric::SquareFoot));
+			"sq feet",
-		assert_eq!(parse_unit("foot²".to_string()), Ok(NonMetric::SquareFoot));
+			"sq ft",
-		assert_eq!(parse_unit("feet²".to_string()), Ok(NonMetric::SquareFoot));
+			"foot²",
-		assert_eq!(parse_unit("ft²".to_string()), Ok(NonMetric::SquareFoot));
+			"feet²",
-		assert_eq!(parse_unit("'²".to_string()), Ok(NonMetric::SquareFoot));
+			"ft²",
-		assert_eq!(parse_unit("′²".to_string()), Ok(NonMetric::SquareFoot));
+			"'²",
-		assert_eq!(parse_unit("foot^2".to_string()), Ok(NonMetric::SquareFoot));
+			"′²",
-		assert_eq!(parse_unit("feet^2".to_string()), Ok(NonMetric::SquareFoot));
+			"foot^2",
-		assert_eq!(parse_unit("ft^2".to_string()), Ok(NonMetric::SquareFoot));
+			"feet^2",
-		assert_eq!(parse_unit("'^2".to_string()), Ok(NonMetric::SquareFoot));
+			"ft^2",
-		assert_eq!(parse_unit("sf".to_string()), Ok(NonMetric::SquareFoot));
+			"'^2",
+			"sf",
+		]);
 
-		assert_eq!(parse_unit("acre".to_string()), Ok(NonMetric::Acre));
+		test_units(NonMetric::Acre, &[
-		assert_eq!(parse_unit("acres".to_string()), Ok(NonMetric::Acre));
+			"acre",
-		assert_eq!(parse_unit("ac".to_string()), Ok(NonMetric::Acre));
+			"acres",
+			"ac",
+		]);
 
-		assert_eq!(parse_unit("square mile".to_string()), Ok(NonMetric::SquareMile));
+		test_units(NonMetric::SquareMile, &[
-		assert_eq!(parse_unit("square miles".to_string()), Ok(NonMetric::SquareMile));
+			"square mile",
-		assert_eq!(parse_unit("square mi".to_string()), Ok(NonMetric::SquareMile));
+			"square miles",
-		assert_eq!(parse_unit("sq mile".to_string()), Ok(NonMetric::SquareMile));
+			"square mi",
-		assert_eq!(parse_unit("sq miles".to_string()), Ok(NonMetric::SquareMile));
+			"sq mile",
-		assert_eq!(parse_unit("sq mi".to_string()), Ok(NonMetric::SquareMile));
+			"sq miles",
-		assert_eq!(parse_unit("mile²".to_string()), Ok(NonMetric::SquareMile));
+			"sq mi",
-		assert_eq!(parse_unit("miles²".to_string()), Ok(NonMetric::SquareMile));
+			"mile²",
-		assert_eq!(parse_unit("mi²".to_string()), Ok(NonMetric::SquareMile));
+			"miles²",
-		assert_eq!(parse_unit("mile^2".to_string()), Ok(NonMetric::SquareMile));
+			"mi²",
-		assert_eq!(parse_unit("miles^2".to_string()), Ok(NonMetric::SquareMile));
+			"mile^2",
-		assert_eq!(parse_unit("mi^2".to_string()), Ok(NonMetric::SquareMile));
+			"miles^2",
+			"mi^2",
+		]);
 
 		// Volume
-		assert_eq!(parse_unit("cubic inch".to_string()), Ok(NonMetric::CubicInch));
+		test_units(NonMetric::CubicInch, &[
-		assert_eq!(parse_unit("cubic inches".to_string()), Ok(NonMetric::CubicInch));
+			"cubic inch",
-		assert_eq!(parse_unit("cubic in".to_string()), Ok(NonMetric::CubicInch));
+			"cubic inches",
-		assert_eq!(parse_unit("cu inch".to_string()), Ok(NonMetric::CubicInch));
+			"cubic in",
-		assert_eq!(parse_unit("cu inches".to_string()), Ok(NonMetric::CubicInch));
+			"cu inch",
-		assert_eq!(parse_unit("cu in".to_string()), Ok(NonMetric::CubicInch));
+			"cu inches",
-		assert_eq!(parse_unit("inch³".to_string()), Ok(NonMetric::CubicInch));
+			"cu in",
-		assert_eq!(parse_unit("inches³".to_string()), Ok(NonMetric::CubicInch));
+			"inch³",
-		assert_eq!(parse_unit("in³".to_string()), Ok(NonMetric::CubicInch));
+			"inches³",
-		assert_eq!(parse_unit("inch^3".to_string()), Ok(NonMetric::CubicInch));
+			"in³",
-		assert_eq!(parse_unit("inches^3".to_string()), Ok(NonMetric::CubicInch));
+			"inch^3",
-		assert_eq!(parse_unit("in^3".to_string()), Ok(NonMetric::CubicInch));
+			"inches^3",
+			"in^3",
+		]);
 
-		assert_eq!(parse_unit("cubic foot".to_string()), Ok(NonMetric::CubicFoot));
+		test_units(NonMetric::CubicFoot, &[
-		assert_eq!(parse_unit("cubic feet".to_string()), Ok(NonMetric::CubicFoot));
+			"cubic foot",
-		assert_eq!(parse_unit("cubic ft".to_string()), Ok(NonMetric::CubicFoot));
+			"cubic feet",
-		assert_eq!(parse_unit("cu foot".to_string()), Ok(NonMetric::CubicFoot));
+			"cubic ft",
-		assert_eq!(parse_unit("cu feet".to_string()), Ok(NonMetric::CubicFoot));
+			"cu foot",
-		assert_eq!(parse_unit("cu ft".to_string()), Ok(NonMetric::CubicFoot));
+			"cu feet",
-		assert_eq!(parse_unit("foot³".to_string()), Ok(NonMetric::CubicFoot));
+			"cu ft",
-		assert_eq!(parse_unit("feet³".to_string()), Ok(NonMetric::CubicFoot));
+			"foot³",
-		assert_eq!(parse_unit("ft³".to_string()), Ok(NonMetric::CubicFoot));
+			"feet³",
-		assert_eq!(parse_unit("foot^3".to_string()), Ok(NonMetric::CubicFoot));
+			"ft³",
-		assert_eq!(parse_unit("feet^3".to_string()), Ok(NonMetric::CubicFoot));
+			"foot^3",
-		assert_eq!(parse_unit("ft^3".to_string()), Ok(NonMetric::CubicFoot));
+			"feet^3",
+			"ft^3",
+		]);
 
 		// Fluid volume
-		assert_eq!(parse_unit("imperial fluid ounce".to_string()), Ok(NonMetric::ImperialFluidOunce));
+		test_units(NonMetric::ImperialFluidOunce, &[
-		assert_eq!(parse_unit("imperial fluid ounces".to_string()), Ok(NonMetric::ImperialFluidOunce));
+			"imperial fluid ounce",
-		assert_eq!(parse_unit("imp fl oz".to_string()), Ok(NonMetric::ImperialFluidOunce));
+			"imperial fluid ounces",
-		assert_eq!(parse_unit("imp fl. oz.".to_string()), Ok(NonMetric::ImperialFluidOunce));
+			"imp fl oz",
-		assert_eq!(parse_unit("imp oz. fl.".to_string()), Ok(NonMetric::ImperialFluidOunce));
+			"imp fl. oz.",
+			"imp oz. fl.",
+		]);
 
-		assert_eq!(parse_unit("imperial pint".to_string()), Ok(NonMetric::ImperialPint));
+		test_units(NonMetric::ImperialPint, &[
-		assert_eq!(parse_unit("imperial pints".to_string()), Ok(NonMetric::ImperialPint));
+			"imperial pint",
-		assert_eq!(parse_unit("imp pt".to_string()), Ok(NonMetric::ImperialPint));
+			"imperial pints",
-		assert_eq!(parse_unit("imp p".to_string()), Ok(NonMetric::ImperialPint));
+			"imp pt",
+			"imp p",
+		]);
 
-		assert_eq!(parse_unit("imperial quart".to_string()), Ok(NonMetric::ImperialQuart));
+		test_units(NonMetric::ImperialQuart, &[
-		assert_eq!(parse_unit("imperial quarts".to_string()), Ok(NonMetric::ImperialQuart));
+			"imperial quart",
-		assert_eq!(parse_unit("imp qt".to_string()), Ok(NonMetric::ImperialQuart));
+			"imperial quarts",
+			"imp qt",
+		]);
 
-		assert_eq!(parse_unit("imperial gallon".to_string()), Ok(NonMetric::ImperialGallon));
+		test_units(NonMetric::ImperialGallon, &[
-		assert_eq!(parse_unit("imperial gallons".to_string()), Ok(NonMetric::ImperialGallon));
+			"imperial gallon",
-		assert_eq!(parse_unit("imp gal".to_string()), Ok(NonMetric::ImperialGallon));
+			"imperial gallons",
+			"imp gal",
+		]);
 
-		assert_eq!(parse_unit("US teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
+		test_units(NonMetric::USTeaspoon, &[
-		assert_eq!(parse_unit("US teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
+			"US teaspoon",
-		assert_eq!(parse_unit("US tsp.".to_string()), Ok(NonMetric::USTeaspoon));
+			"US teaspoons",
-		assert_eq!(parse_unit("US tsp".to_string()), Ok(NonMetric::USTeaspoon));
+			"US tsp.",
-		assert_eq!(parse_unit("us teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
+			"US tsp",
-		assert_eq!(parse_unit("us teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
+			"us teaspoon",
-		assert_eq!(parse_unit("us tsp.".to_string()), Ok(NonMetric::USTeaspoon));
+			"us teaspoons",
-		assert_eq!(parse_unit("us tsp".to_string()), Ok(NonMetric::USTeaspoon));
+			"us tsp.",
-		assert_eq!(parse_unit("teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
+			"us tsp",
-		assert_eq!(parse_unit("teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
+			"teaspoon",
-		assert_eq!(parse_unit("tsp.".to_string()), Ok(NonMetric::USTeaspoon));
+			"teaspoons",
-		assert_eq!(parse_unit("tsp".to_string()), Ok(NonMetric::USTeaspoon));
+			"tsp.",
+			"tsp",
+		]);
 
-		assert_eq!(parse_unit("US tablespoon".to_string()), Ok(NonMetric::USTablespoon));
+		test_units(NonMetric::USTablespoon, &[
-		assert_eq!(parse_unit("US tablespoons".to_string()), Ok(NonMetric::USTablespoon));
+			"US tablespoon",
-		assert_eq!(parse_unit("US Tbsp.".to_string()), Ok(NonMetric::USTablespoon));
+			"US tablespoons",
-		assert_eq!(parse_unit("US Tbsp".to_string()), Ok(NonMetric::USTablespoon));
+			"US Tbsp.",
-		assert_eq!(parse_unit("us tablespoon".to_string()), Ok(NonMetric::USTablespoon));
+			"US Tbsp",
-		assert_eq!(parse_unit("us tablespoons".to_string()), Ok(NonMetric::USTablespoon));
+			"us tablespoon",
-		assert_eq!(parse_unit("us tbsp.".to_string()), Ok(NonMetric::USTablespoon));
+			"us tablespoons",
-		assert_eq!(parse_unit("us tbsp".to_string()), Ok(NonMetric::USTablespoon));
+			"us tbsp.",
-		assert_eq!(parse_unit("tablespoon".to_string()), Ok(NonMetric::USTablespoon));
+			"us tbsp",
-		assert_eq!(parse_unit("tablespoons".to_string()), Ok(NonMetric::USTablespoon));
+			"tablespoon",
-		assert_eq!(parse_unit("Tbsp.".to_string()), Ok(NonMetric::USTablespoon));
+			"tablespoons",
-		assert_eq!(parse_unit("Tbsp".to_string()), Ok(NonMetric::USTablespoon));
+			"Tbsp.",
-		assert_eq!(parse_unit("tbsp.".to_string()), Ok(NonMetric::USTablespoon));
+			"Tbsp",
-		assert_eq!(parse_unit("tbsp".to_string()), Ok(NonMetric::USTablespoon));
+			"tbsp.",
+			"tbsp",
+		]);
 
-		assert_eq!(parse_unit("US fluid ounce".to_string()), Ok(NonMetric::USFluidOunce));
+		test_units(NonMetric::USFluidOunce, &[
-		assert_eq!(parse_unit("US fluid ounces".to_string()), Ok(NonMetric::USFluidOunce));
+			"US fluid ounce",
-		assert_eq!(parse_unit("US fl oz".to_string()), Ok(NonMetric::USFluidOunce));
+			"US fluid ounces",
-		assert_eq!(parse_unit("US fl. oz.".to_string()), Ok(NonMetric::USFluidOunce));
+			"US fl oz",
-		assert_eq!(parse_unit("US oz. fl.".to_string()), Ok(NonMetric::USFluidOunce));
+			"US fl. oz.",
-		assert_eq!(parse_unit("us fluid ounce".to_string()), Ok(NonMetric::USFluidOunce));
+			"US oz. fl.",
-		assert_eq!(parse_unit("us fluid ounces".to_string()), Ok(NonMetric::USFluidOunce));
+			"us fluid ounce",
-		assert_eq!(parse_unit("us fl oz".to_string()), Ok(NonMetric::USFluidOunce));
+			"us fluid ounces",
-		assert_eq!(parse_unit("us fl. oz.".to_string()), Ok(NonMetric::USFluidOunce));
+			"us fl oz",
-		assert_eq!(parse_unit("us oz. fl.".to_string()), Ok(NonMetric::USFluidOunce));
+			"us fl. oz.",
+			"us oz. fl.",
+		]);
 
-		assert_eq!(parse_unit("US cup".to_string()), Ok(NonMetric::USCup));
+		test_units(NonMetric::USCup, &[
-		assert_eq!(parse_unit("US cups".to_string()), Ok(NonMetric::USCup));
+			"US cup",
-		assert_eq!(parse_unit("us cup".to_string()), Ok(NonMetric::USCup));
+			"US cups",
-		assert_eq!(parse_unit("us cups".to_string()), Ok(NonMetric::USCup));
+			"us cup",
+			"us cups",
+		]);
 
-		assert_eq!(parse_unit("US liquid pint".to_string()), Ok(NonMetric::USLiquidPint));
+		test_units(NonMetric::USLiquidPint, &[
-		assert_eq!(parse_unit("US liquid pints".to_string()), Ok(NonMetric::USLiquidPint));
+			"US liquid pint",
-		assert_eq!(parse_unit("US pint".to_string()), Ok(NonMetric::USLiquidPint));
+			"US liquid pints",
-		assert_eq!(parse_unit("US pints".to_string()), Ok(NonMetric::USLiquidPint));
+			"US pint",
-		assert_eq!(parse_unit("US pt".to_string()), Ok(NonMetric::USLiquidPint));
+			"US pints",
-		assert_eq!(parse_unit("US p".to_string()), Ok(NonMetric::USLiquidPint));
+			"US pt",
-		assert_eq!(parse_unit("us liquid pint".to_string()), Ok(NonMetric::USLiquidPint));
+			"US p",
-		assert_eq!(parse_unit("us liquid pints".to_string()), Ok(NonMetric::USLiquidPint));
+			"us liquid pint",
-		assert_eq!(parse_unit("us pint".to_string()), Ok(NonMetric::USLiquidPint));
+			"us liquid pints",
-		assert_eq!(parse_unit("us pints".to_string()), Ok(NonMetric::USLiquidPint));
+			"us pint",
-		assert_eq!(parse_unit("us pt".to_string()), Ok(NonMetric::USLiquidPint));
+			"us pints",
-		assert_eq!(parse_unit("us p".to_string()), Ok(NonMetric::USLiquidPint));
+			"us pt",
+			"us p",
+		]);
 
-		assert_eq!(parse_unit("US liquid quart".to_string()), Ok(NonMetric::USLiquidQuart));
+		test_units(NonMetric::USLiquidQuart, &[
-		assert_eq!(parse_unit("US liquid quarts".to_string()), Ok(NonMetric::USLiquidQuart));
+			"US liquid quart",
-		assert_eq!(parse_unit("US quart".to_string()), Ok(NonMetric::USLiquidQuart));
+			"US liquid quarts",
-		assert_eq!(parse_unit("US quarts".to_string()), Ok(NonMetric::USLiquidQuart));
+			"US quart",
-		assert_eq!(parse_unit("US qt".to_string()), Ok(NonMetric::USLiquidQuart));
+			"US quarts",
-		assert_eq!(parse_unit("us liquid quart".to_string()), Ok(NonMetric::USLiquidQuart));
+			"US qt",
-		assert_eq!(parse_unit("us liquid quarts".to_string()), Ok(NonMetric::USLiquidQuart));
+			"us liquid quart",
-		assert_eq!(parse_unit("us quart".to_string()), Ok(NonMetric::USLiquidQuart));
+			"us liquid quarts",
-		assert_eq!(parse_unit("us quarts".to_string()), Ok(NonMetric::USLiquidQuart));
+			"us quart",
-		assert_eq!(parse_unit("us qt".to_string()), Ok(NonMetric::USLiquidQuart));
+			"us quarts",
+			"us qt",
+		]);
 
-		assert_eq!(parse_unit("US gallon".to_string()), Ok(NonMetric::USGallon));
+		test_units(NonMetric::USGallon, &[
-		assert_eq!(parse_unit("US gallons".to_string()), Ok(NonMetric::USGallon));
+			"US gallon",
-		assert_eq!(parse_unit("US gal".to_string()), Ok(NonMetric::USGallon));
+			"US gallons",
-		assert_eq!(parse_unit("us gallon".to_string()), Ok(NonMetric::USGallon));
+			"US gal",
-		assert_eq!(parse_unit("us gallons".to_string()), Ok(NonMetric::USGallon));
+			"us gallon",
-		assert_eq!(parse_unit("us gal".to_string()), Ok(NonMetric::USGallon));
+			"us gallons",
+			"us gal",
+		]);
+	}
+
+	fn test_units(unit: NonMetric, spellings: &[&str]) {
+		for spelling in spellings {
+			assert_eq!(parse_unit(spelling.to_string()), Ok(unit));
+		}
 	}
 
 	#[test]
 	fn ambiguous_units() {
-		assert_eq!(
+		test_ambiguous_units(NonMetric::ShortTon, NonMetric::LongTon, &[
-			parse_unit("fluid ounce".to_string()),
+			"ton",
-			Err(ParseError::AmbiguousUnit("fluid ounce".to_string(), "imperial", "US"))
+			"tons",
-		);
+		]);
-		assert_eq!(
-			parse_unit("fluid ounces".to_string()),
-			Err(ParseError::AmbiguousUnit("fluid ounces".to_string(), "imperial", "US"))
-		);
-		assert_eq!(
-			parse_unit("fl oz".to_string()),
-			Err(ParseError::AmbiguousUnit("fl oz".to_string(), "imp", "US"))
-		);
-		assert_eq!(
-			parse_unit("fl. oz.".to_string()),
-			Err(ParseError::AmbiguousUnit("fl. oz.".to_string(), "imp", "US"))
-		);
-		assert_eq!(
-			parse_unit("oz. fl.".to_string()),
-			Err(ParseError::AmbiguousUnit("oz. fl.".to_string(), "imp", "US"))
-		);
 
-		assert_eq!(
+		test_ambiguous_units(NonMetric::ImperialFluidOunce, NonMetric::USFluidOunce, &[
-			parse_unit("pint".to_string()),
-			Err(ParseError::AmbiguousUnit("pint".to_string(), "imperial", "US"))
-		);
-		assert_eq!(
-			parse_unit("pints".to_string()),
-			Err(ParseError::AmbiguousUnit("pints".to_string(), "imperial", "US"))
-		);
-		assert_eq!(
-			parse_unit("pt".to_string()),
-			Err(ParseError::AmbiguousUnit("pt".to_string(), "imp", "US"))
-		);
-		assert_eq!(
-			parse_unit("p".to_string()),
-			Err(ParseError::AmbiguousUnit("p".to_string(), "imp", "US"))
-		);
-
-		assert_eq!(
-			parse_unit("quart".to_string()),
-			Err(ParseError::AmbiguousUnit("quart".to_string(), "imperial", "US"))
-		);
-		assert_eq!(
-			parse_unit("quarts".to_string()),
-			Err(ParseError::AmbiguousUnit("quarts".to_string(), "imperial", "US"))
-		);
-		assert_eq!(
-			parse_unit("qt".to_string()),
-			Err(ParseError::AmbiguousUnit("qt".to_string(), "imp", "US"))
-		);
-
-		assert_eq!(
-			parse_unit("gallon".to_string()),
-			Err(ParseError::AmbiguousUnit("gallon".to_string(), "imperial", "US"))
-		);
-		assert_eq!(
-			parse_unit("gallons".to_string()),
-			Err(ParseError::AmbiguousUnit("gallons".to_string(), "imperial", "US"))
-		);
-		assert_eq!(
-			parse_unit("gal".to_string()),
-			Err(ParseError::AmbiguousUnit("gal".to_string(), "imp", "US"))
-		);
-	}
-
-	#[test]
-	fn ambiguous_unit_suggestions() {
-		let ambiguous_units = [
 			"fluid ounce",
 			"fluid ounces",
 			"fl oz",
 			"fl. oz.",
 			"oz. fl.",
+		]);
 
+		test_ambiguous_units(NonMetric::ImperialPint, NonMetric::USLiquidPint, &[
 			"pint",
 			"pints",
 			"pt",
 			"p",
+		]);
 
+		test_ambiguous_units(NonMetric::ImperialQuart, NonMetric::USLiquidQuart, &[
 			"quart",
 			"quarts",
 			"qt",
+		]);
 
+		test_ambiguous_units(NonMetric::ImperialGallon, NonMetric::USGallon, &[
 			"gallon",
 			"gallons",
 			"gal",
-		];
+		]);
+	}
 
-		for unit in ambiguous_units {
+	fn test_ambiguous_units(unit1: NonMetric, unit2: NonMetric, spellings: &[&str]) {
-			let parsed = parse_unit(unit.to_string());
+		for spelling in spellings {
-			if let Err(ParseError::AmbiguousUnit(unit, prefix1, prefix2)) = parsed {
+			let parsed = parse_unit(spelling.to_string());
-				let suggestion1 = format!("{prefix1} {unit}");
+			if let Err(ParseError::AmbiguousUnit(unit_name, prefix1, prefix2)) = parsed {
-				let suggestion2 = format!("{prefix2} {unit}");
+				assert_eq!(&unit_name, spelling);
-				assert!(parse_unit(suggestion1).is_ok());
+				let suggestion1 = format!("{prefix1} {unit_name}");
-				assert!(parse_unit(suggestion2).is_ok());
+				let suggestion2 = format!("{prefix2} {unit_name}");
+				assert_eq!(parse_unit(suggestion1), Ok(unit1));
+				assert_eq!(parse_unit(suggestion2), Ok(unit2));
 			} else {
-				unreachable!();
+				panic!("units passed to test_ambiguous_units() must be ambiguous");
 			}
 		}
 	}

src/units.rs

@@ -19,6 +19,8 @@ pub enum NonMetric {
 	Ounce,
 	Pound,
 	Stone,
+	ShortTon,
+	LongTon,
 	// Temperature
 	Fahrenheit,
 	// Area