Merge pull request #19 from segeljakt/rust-dev

Refactor and add tests

Author: scotts

.gitignore

@@ -2,6 +2,7 @@
 # will have compiled files and executables
 debug/
 target/
+wip/
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html

.travis.yml

@@ -1,5 +1,11 @@
 dist: bionic
-language: cpp
-jobs:
+matrix:
   include:
-      - script: cpp/build-and-test.sh
+    - language: cpp
+      rust: stable
+      jobs:
+        allow_failures:
+          - rust: nightly
+          fast_finish: true
+    - language: cpp
+      script: cpp/build-and-test.sh

rust/Cargo.toml

@@ -25,6 +25,7 @@ rand               = "0.7.3"
 
 [dev-dependencies]
 criterion          = "0.3.3"
+trybuild           = "1.0.30"
 
 [profile.dev]
 opt-level          = 0

rust/src/reactive/flat_fat.rs

@@ -2,7 +2,7 @@ use alga::general::AbstractMonoid;
 use alga::general::Operator;
 use std::collections::HashSet;
 
-pub trait FAT<Value, BinOp>
+pub(crate) trait FAT<Value, BinOp>
 where
     Value: AbstractMonoid<BinOp> + Clone,
     BinOp: Operator,
@@ -33,7 +33,7 @@ where
     fn suffix(&self, i: usize) -> Value;
 }
 
-pub struct FlatFAT<Value, BinOp>
+pub(crate) struct FlatFAT<Value, BinOp>
 where
     Value: AbstractMonoid<BinOp> + Clone,
     BinOp: Operator,

rust/tests/common.rs

@@ -0,0 +1,112 @@
+use alga::general::AbstractGroup;
+use alga::general::AbstractLoop;
+use alga::general::AbstractMagma;
+use alga::general::AbstractMonoid;
+use alga::general::AbstractQuasigroup;
+use alga::general::AbstractSemigroup;
+use alga::general::Identity;
+use alga::general::Operator;
+use alga::general::TwoSidedInverse;
+
+/// Abstract Algebra Lattice:
+/// Borrowed from https://docs.rs/alga/0.9.3/alga/general/index.html
+///
+///                           AbstractMagma
+///                                |
+///                        _______/ \______
+///                       /                \
+///                 divisibility       associativity
+///                      |                  |
+///                      V                  V
+///                AbstractQuasigroup AbstractSemigroup
+///                      |                  |
+///                  identity            identity
+///                      |                  |
+///                      V                  V
+///                 AbstractLoop       AbstractMonoid
+///                      |                  |
+///                 associativity     invertibility
+///                       \______   _______/
+///                              \ /
+///                               |
+///                               V
+///                         AbstractGroup
+///                               |
+///                         commutativity
+///                               |
+///                               V
+///                     AbstractGroupAbelian
+
+/// An integer value
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct Int(pub i32);
+
+/// Binary operator for calculating the arithmetic sum.
+/// Has the following properties:
+/// * Invertibility
+/// * Associativity
+/// * Commutativity
+#[derive(Copy, Clone)]
+pub struct Sum;
+
+impl Operator for Sum {
+    fn operator_token() -> Sum {
+        Sum
+    }
+}
+
+impl Identity<Sum> for Int {
+    fn identity() -> Int {
+        Int(0)
+    }
+}
+
+impl AbstractMagma<Sum> for Int {
+    fn operate(&self, other: &Self) -> Self {
+        Int(self.0 + other.0)
+    }
+}
+
+impl TwoSidedInverse<Sum> for Int {
+    fn two_sided_inverse(&self) -> Int {
+        Int(-self.0)
+    }
+}
+
+impl AbstractSemigroup<Sum> for Int {}
+impl AbstractMonoid<Sum> for Int {}
+impl AbstractQuasigroup<Sum> for Int {}
+impl AbstractLoop<Sum> for Int {}
+impl AbstractGroup<Sum> for Int {}
+
+/// Binary operator for calculating the maximum Int.
+/// Has the following properties:
+/// * Associativity
+/// * Commutativity
+#[derive(Copy, Clone)]
+pub(crate) struct Max;
+
+impl Operator for Max {
+    fn operator_token() -> Max {
+        Max
+    }
+}
+
+impl Identity<Max> for Int {
+    fn identity() -> Int {
+        Int(std::i32::MIN)
+    }
+}
+
+impl AbstractMagma<Max> for Int {
+    fn operate(&self, other: &Self) -> Self {
+        if self.0 > other.0 {
+            *self
+        } else {
+            *other
+        }
+    }
+}
+
+impl AbstractSemigroup<Max> for Int {}
+impl AbstractMonoid<Max> for Int {}