6 files changed, 357 insertions, 0 deletions

diff --git a/rust/triangle/.exercism/metadata.json b/rust/triangle/.exercism/metadata.json
new file mode 100644
index 0000000..3210561
--- /dev/null
+++ b/rust/triangle/.exercism/metadata.json
@@ -0,0 +1 @@
+{"track":"rust","exercise":"triangle","id":"c3fbb35fa9084358852226269ba3ed1b","url":"https://exercism.io/my/solutions/c3fbb35fa9084358852226269ba3ed1b","handle":"dyamon","is_requester":true,"auto_approve":false}
\ No newline at end of file
diff --git a/rust/triangle/.gitignore b/rust/triangle/.gitignore
new file mode 100644
index 0000000..db7f315
--- /dev/null
+++ b/rust/triangle/.gitignore
@@ -0,0 +1,8 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+**/*.rs.bk
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock
diff --git a/rust/triangle/Cargo.toml b/rust/triangle/Cargo.toml
new file mode 100644
index 0000000..4042a35
--- /dev/null
+++ b/rust/triangle/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+edition = "2018"
+name = "triangle"
+version = "0.0.0"
+
+[features]
+generic = []
diff --git a/rust/triangle/README.md b/rust/triangle/README.md
new file mode 100644
index 0000000..fe094f7
--- /dev/null
+++ b/rust/triangle/README.md
@@ -0,0 +1,131 @@
+# Triangle
+
+Determine if a triangle is equilateral, isosceles, or scalene.
+
+An _equilateral_ triangle has all three sides the same length.
+
+An _isosceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)
+
+A _scalene_ triangle has all sides of different lengths.
+
+## Note
+
+For a shape to be a triangle at all, all sides have to be of length > 0, and
+the sum of the lengths of any two sides must be greater than or equal to the
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+
+## Dig Deeper
+
+The case where the sum of the lengths of two sides _equals_ that of the
+third is known as a _degenerate_ triangle - it has zero area and looks like
+a single line. Feel free to add your own code/tests to check for degenerate triangles.
+
+# Triangle in Rust
+
+- [Result](https://doc.rust-lang.org/std/result/index.html)
+
+Implementation of this can take many forms. Here are some topics that may help you, depending on the approach you take.
+
+- [Enums](https://doc.rust-lang.org/book/2018-edition/ch06-00-enums.html)
+- [Traits](https://doc.rust-lang.org/book/2018-edition/ch10-02-traits.html)
+- [BTreeSet](https://doc.rust-lang.org/std/collections/btree_set/struct.BTreeSet.html)
+
+Or maybe you will come up with an approach that uses none of those!
+
+## Non-integer lengths
+
+The base exercise tests identification of triangles whose sides are all
+integers. However, some triangles cannot be represented by pure integers. A simple example is a right triangle (an isosceles triangle whose equal sides are separated by 90 degrees) whose equal sides both have length of 1. Its hypotenuse is the square root of 2, which is an irrational number: no simple multiplication can represent this number as an integer.
+
+It would be tedious to rewrite the analysis functions to handle both integer and floating-point cases, and particularly tedious to do so for all potential integer and floating point types: given signed and unsigned variants of bitwidths 8, 16, 32, 64, and 128, that would be 10 reimplementations of fundamentally the same code even before considering floats!
+
+There's a better way: [generics](https://doc.rust-lang.org/stable/book/2018-edition/ch10-00-generics.html). By rewriting your Triangle as a `Triangle<T>`, you can write your code once, and hand off the work of generating all those specializations to the compiler. Note that in order to use mathematical operations, you'll need to constrain your generic type to types which support those operations using traits.
+
+There are some bonus tests you can run which test your implementation on floating-point numbers. To enable them, run your tests with the `generic` feature flag, like this:
+
+```bash
+cargo test --features generic
+```
+
+
+## Rust Installation
+
+Refer to the [exercism help page][help-page] for Rust installation and learning
+resources.
+
+## Writing the Code
+
+Execute the tests with:
+
+```bash
+$ cargo test
+```
+
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file which is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test.
+
+If you wish to run all ignored tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specific test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
+
+Make sure to read the [Modules][modules] chapter if you
+haven't already, it will help you with organizing your files.
+
+## Further improvements
+
+After you have solved the exercise, please consider using the additional utilities, described in the [installation guide](https://exercism.io/tracks/rust/installation), to further refine your final solution.
+
+To format your solution, inside the solution directory use
+
+```bash
+cargo fmt
+```
+
+To see, if your solution contains some common ineffective use cases, inside the solution directory use
+
+```bash
+cargo clippy --all-targets
+```
+
+## Submitting the solution
+
+Generally you should submit all files in which you implemented your solution (`src/lib.rs` in most cases). If you are using any external crates, please consider submitting the `Cargo.toml` file. This will make the review process faster and clearer.
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/rust](https://github.com/exercism/rust) repository on GitHub is the home for all of the Rust exercises. If you have feedback about an exercise, or want to help implement new exercises, head over there and create an issue. Members of the rust track team are happy to help!
+
+If you want to know more about Exercism, take a look at the [contribution guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/README.md).
+
+[help-page]: https://exercism.io/tracks/rust/learning
+[modules]: https://doc.rust-lang.org/book/ch07-02-defining-modules-to-control-scope-and-privacy.html
+[cargo]: https://doc.rust-lang.org/book/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/ch11-02-running-tests.html
+
+## Source
+
+The Ruby Koans triangle project, parts 1 & 2 [http://rubykoans.com](http://rubykoans.com)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
diff --git a/rust/triangle/src/lib.rs b/rust/triangle/src/lib.rs
new file mode 100644
index 0000000..f4486fe
--- /dev/null
+++ b/rust/triangle/src/lib.rs
@@ -0,0 +1,27 @@
+use std::ops::Add;
+
+pub struct Triangle<T>([T; 3]);
+
+impl<T> Triangle<T>
+where
+    T: Add<Output = T> + PartialOrd + Copy,
+{
+    pub fn build(sides: [T; 3]) -> Option<Triangle<T>> {
+        Some(Triangle(sides))
+            .filter(|_| sides[0] + sides[1] > sides[2])
+            .filter(|_| sides[1] + sides[2] > sides[0])
+            .filter(|_| sides[0] + sides[2] > sides[1])
+    }
+
+    pub fn is_equilateral(&self) -> bool {
+        self.0[0] == self.0[1] && self.0[1] == self.0[2]
+    }
+
+    pub fn is_scalene(&self) -> bool {
+        self.0[0] != self.0[1] && self.0[1] != self.0[2] && self.0[0] != self.0[2]
+    }
+
+    pub fn is_isosceles(&self) -> bool {
+        !(self.is_equilateral() || self.is_scalene())
+    }
+}
diff --git a/rust/triangle/tests/triangle.rs b/rust/triangle/tests/triangle.rs
new file mode 100644
index 0000000..f3e4d8a
--- /dev/null
+++ b/rust/triangle/tests/triangle.rs
@@ -0,0 +1,183 @@
+use triangle::*;
+
+#[test]
+fn positive_length_sides_are_ok() {
+    let sides = [2, 2, 2];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_some());
+}
+
+#[test]
+fn zero_length_sides_are_illegal() {
+    let sides = [0, 0, 0];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}
+
+#[test]
+fn one_length_zero_side_first() {
+    let sides = [0, 2, 2];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}
+
+#[test]
+fn one_length_zero_side_second() {
+    let sides = [2, 0, 2];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}
+
+#[test]
+fn one_length_zero_side_third() {
+    let sides = [2, 2, 0];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}
+
+#[test]
+fn equilateral_triangles_have_equal_sides() {
+    let sides = [2, 2, 2];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(triangle.is_equilateral());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+fn larger_equilateral_triangles_have_equal_sides() {
+    let sides = [10, 10, 10];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(triangle.is_equilateral());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+fn isosceles_triangles_have_two_equal_sides_one() {
+    let sides = [3, 4, 4];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(triangle.is_isosceles());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+fn isosceles_triangles_have_two_equal_sides_two() {
+    let sides = [4, 4, 3];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(triangle.is_isosceles());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+fn isosceles_triangles_have_two_equal_sides_three() {
+    let sides = [4, 3, 4];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(triangle.is_isosceles());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+fn isosceles_triangles_have_two_equal_sides_four() {
+    let sides = [4, 7, 4];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(triangle.is_isosceles());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+fn scalene_triangle_has_no_equal_sides_one() {
+    let sides = [3, 4, 5];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(!triangle.is_isosceles());
+    assert!(triangle.is_scalene());
+}
+
+#[test]
+fn scalene_triangle_has_no_equal_sides_two() {
+    let sides = [5, 4, 6];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(!triangle.is_isosceles());
+    assert!(triangle.is_scalene());
+}
+
+#[test]
+fn scalene_triangle_has_no_equal_sides_three() {
+    let sides = [10, 11, 12];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(!triangle.is_isosceles());
+    assert!(triangle.is_scalene());
+}
+
+#[test]
+fn scalene_triangle_has_no_equal_sides_four() {
+    let sides = [5, 4, 2];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(!triangle.is_isosceles());
+    assert!(triangle.is_scalene());
+}
+
+#[test]
+fn sum_of_two_sides_must_equal_or_exceed_the_remaining_side_one() {
+    let sides = [7, 3, 2];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}
+
+#[test]
+fn sum_of_two_sides_must_equal_or_exceed_the_remaining_side_two() {
+    let sides = [1, 1, 3];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}
+
+#[test]
+#[cfg(feature = "generic")]
+fn scalene_triangle_with_floating_point_sides() {
+    let sides = [0.4, 0.6, 0.3];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(!triangle.is_isosceles());
+    assert!(triangle.is_scalene());
+}
+
+#[test]
+#[cfg(feature = "generic")]
+fn equilateral_triangles_with_floating_point_sides() {
+    let sides = [0.2, 0.2, 0.2];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(triangle.is_equilateral());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+#[cfg(feature = "generic")]
+fn isosceles_triangle_with_floating_point_sides() {
+    let sides = [0.3, 0.4, 0.4];
+    let triangle = Triangle::build(sides).unwrap();
+    assert!(!triangle.is_equilateral());
+    assert!(triangle.is_isosceles());
+    assert!(!triangle.is_scalene());
+}
+
+#[test]
+#[cfg(feature = "generic")]
+fn invalid_triangle_with_floating_point_sides_one() {
+    let sides = [0.0, 0.4, 0.3];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}
+
+#[test]
+#[cfg(feature = "generic")]
+fn invalid_triangle_with_floating_point_sides_two() {
+    let sides = [0.1, 0.3, 0.5];
+    let triangle = Triangle::build(sides);
+    assert!(triangle.is_none());
+}