Mostly working now

src/lib/DataStructures/HashSet.vala

@@ -11,6 +11,7 @@ namespace Invercargill.DataStructures {
         private int n_items = 0;
         private int n_buckets = 16;
         private int n_collissions = 0;
+        private int next_item_index = 0;
         private SafeReadFunc<T>? safe_read;
         private SafeWriteFunc<T>? safe_write;
         private HashDelegate<T> hash_func;
@@ -92,8 +93,9 @@ namespace Invercargill.DataStructures {
 
         private uint add_item(T item) {
             ensure_room_for_items(1);
-            write_item(n_items, item);
+            write_item(next_item_index, item);
             n_items++;
+            next_item_index++;
             return n_items;
         }
 
@@ -113,9 +115,7 @@ namespace Invercargill.DataStructures {
         public override Tracker<T> get_tracker () {
             return range(0, buckets.length)
                 .where(i => buckets[i] != BUCKET_EMPTY && buckets[i] != BUCKET_TOMBSTONE)
-                .debug_trace("buket number")
                 .select<T>(i => get_item(buckets[i]))
-                .debug_trace("hashset tracker!")
                 .get_tracker();
         }
 
@@ -191,16 +191,16 @@ namespace Invercargill.DataStructures {
                 if(buckets[bucket_index] != BUCKET_TOMBSTONE) {
                     var ours = get_item(buckets[bucket_index]);
                     if(equal_func(ours, item)) {
-                        write_item(buckets[bucket_index], null);
+                        write_item(buckets[bucket_index] - 1, null);
                         buckets[bucket_index] = BUCKET_TOMBSTONE;
                         n_items--;
-                        print(@"Removed $((int)item)\n");
                         return ours;
                     }
+                    else {
+                    }
                 }
                 bucket_index++;
             }
-            print(@"Did not remove $((int)item)\n");
             return null;
         }
 
@@ -208,10 +208,10 @@ namespace Invercargill.DataStructures {
             if(other == this) {
                 return true;
             }
-            return other.debug_trace("other").non_common(this.debug_trace("this"), hash_func, equal_func).debug_trace("Non common").count() == 0;
+            return other.non_common(this, hash_func, equal_func).count() == 0;
         }
         public bool is_subset_of(Enumerable<T> other) {
-            return this.exclude(other, hash_func, equal_func).count() == 0;
+            return this.exclude(other, hash_func, equal_func).debug_trace("subset").count() == 0;
         }
         public bool is_proper_subset_of(Enumerable<T> other) {
             return !equals(other) && is_subset_of(other);

src/lib/Interfaces/ReadOnlySet.vala

@@ -11,7 +11,7 @@ namespace Invercargill {
 
         public virtual bool is_proper_superset_of(Enumerable<T> other) {
             var search = other.partition(i => has(i));
-            return search.matching.any() && search.matching.any();
+            return (search.matching.any() && search.non_matching.any()) || (search.all_items.count() == 0 && count() != 0);
         }
         public virtual bool is_superset_of(Enumerable<T> other) {
             return other == this || other.all(i => has(i));

src/lib/Interfaces/Set.vala

@@ -19,8 +19,6 @@ namespace Invercargill {
         public virtual void symmetric_except_with(Enumerable<T> items) {
             var other = items.cache();
             var to_remove = other.where(i => has(i)).to_series();
-            other.debug_dump("other");
-            to_remove.debug_dump("To remove");
             union_with(other);
             except_with(to_remove);
         }

src/lib/Modifiers/Difference.vala

@@ -32,7 +32,7 @@ namespace Invercargill.Modifiers {
 
             return new AdvanceTracker<T>((out result) => {
                 T? item = null;
-                while(item != null) {
+                while(item == null) {
                     if(tracker.has_next()) {
                         item = tracker.get_next();
                     }

src/lib/Modifiers/Intersect.vala

@@ -32,7 +32,7 @@ namespace Invercargill.Modifiers {
 
             return new AdvanceTracker<T>((out result) => {
                 T? item = null;
-                while(item != null) {
+                while(item == null) {
                     if(tracker.has_next()) {
                         item = tracker.get_next();
                     }

src/lib/Modifiers/SymmetricDifference.vala

@@ -28,9 +28,7 @@ namespace Invercargill.Modifiers {
 
         public override Tracker<T> get_tracker() {
             var result = e1.to_hash_set(i => key_hf(key_sf(i)), (a, b) => key_ef(key_sf(a), key_sf(b)));
-            result.debug_dump("Pre execpt");
             result.symmetric_except_with(e2);
-            result.debug_dump("Post execpt");
             return result.get_tracker();
         }
 

src/lib/Modifiers/Union.vala

@@ -33,7 +33,7 @@ namespace Invercargill.Modifiers {
 
             return new AdvanceTracker<T>((out result) => {
                 T? item = null;
-                while(item != null) {
+                while(item == null) {
                     if(tracker1.has_next()) {
                         item = tracker1.get_next();
                     }

src/lib/Partition.vala

@@ -5,6 +5,7 @@ namespace Invercargill {
 
         public ImmutableLot<T> matching { get; private set; }
         public ImmutableLot<T> non_matching { get; private set; }
+        public Enumerable<T> all_items { get; private set; }
 
         public Partition(Enumerable<T> items, PredicateDelegate<T> test) {
             var match = new DataStructures.Series<T>();
@@ -19,6 +20,7 @@ namespace Invercargill {
             }
             matching = match.to_immutable_buffer();
             non_matching = non_match.to_immutable_buffer();
+            all_items = matching.concat(non_matching);
         }
         
     }

src/tests/Integration/Set.vala

@@ -51,28 +51,28 @@ void set_tests() {
         assert_true(hashset.is_superset_of(empty));
         assert_false(hashset.is_proper_subset_of(empty));
         assert_true(hashset.is_proper_superset_of(empty));
-        assert_false(hashset.overlaps(equal));
+        assert_false(hashset.overlaps(empty));
 
         assert_false(hashset.equals(sup_set));
         assert_true(hashset.is_subset_of(sup_set));
         assert_false(hashset.is_superset_of(sup_set));
         assert_true(hashset.is_proper_subset_of(sup_set));
         assert_false(hashset.is_proper_superset_of(sup_set));
-        assert_true(hashset.overlaps(equal));
+        assert_true(hashset.overlaps(sup_set));
 
         assert_false(hashset.equals(sub_set));
         assert_false(hashset.is_subset_of(sub_set));
         assert_true(hashset.is_superset_of(sub_set));
         assert_false(hashset.is_proper_subset_of(sub_set));
         assert_true(hashset.is_proper_superset_of(sub_set));
-        assert_true(hashset.overlaps(equal));
+        assert_true(hashset.overlaps(sub_set));
 
         assert_false(hashset.equals(overlap));
         assert_false(hashset.is_subset_of(overlap));
         assert_false(hashset.is_superset_of(overlap));
         assert_false(hashset.is_proper_subset_of(overlap));
         assert_false(hashset.is_proper_superset_of(overlap));
-        assert_true(hashset.overlaps(equal));
+        assert_true(hashset.overlaps(overlap));
 
     });
 }