Rename some stuffs

src/lib/Collections/BinaryData.vala

@@ -189,7 +189,7 @@ namespace Invercargill {
         }
 
         public uint hash_code() {
-            return aggrigate<uint>(5381, (h, b) => h * 33 + b);
+            return aggregate<uint>(5381, (h, b) => h * 33 + b);
         }
 
         public void push_int32(int32 value) {

src/lib/Delegates.vala

@@ -8,7 +8,7 @@ namespace Invercargill {
 
     public delegate bool PredicateDelegate<T>(T item);
 
-    public delegate Taggrigate AggrigateDelegate<Taggrigate, Tin>(Taggrigate aggrigate, Tin item);
+    public delegate Taggregate AggregateDelegate<Taggregate, Tin>(Taggregate aggregate, Tin item);
 
     public delegate int CompareDelegate<T>(T a, T b);
 

src/lib/Enumerable.vala

@@ -173,12 +173,12 @@ namespace Invercargill {
             });
         }
 
-        public virtual Tout aggrigate<Tout>(Tout initial, AggrigateDelegate<Tout, T> aggrigate_func) {
-            var aggrigate = initial;
+        public virtual Tout aggregate<Tout>(Tout initial, AggregateDelegate<Tout, T> aggregate_func) {
+            var aggregate = initial;
             iterate(i => {
-                aggrigate = aggrigate_func(aggrigate, i);
+                aggregate = aggregate_func(aggregate, i);
             });
-            return aggrigate;
+            return aggregate;
         }
 
         public virtual T max(TransformDelegate<T, int> int_delegate) {
@@ -231,13 +231,13 @@ namespace Invercargill {
             return new PairEnumerable<T, Tother>(this, other);
         }
 
-        public virtual Enumerable<T> zip(Enumerable<T> other) {
+        public virtual Enumerable<T> interleave(Enumerable<T> other) {
             return new ZipperEnumerable<T>(this, other);
         }
 
         public virtual Enumerable<Tout> fork<Tout>(owned TransformDelegate<T, Tout> fork1, owned TransformDelegate<T, Tout> fork2) {
             var seq = to_series();
-            return seq.select<Tout>((owned)fork1).zip(seq.select<Tout>((owned)fork2));
+            return seq.select<Tout>((owned)fork1).interleave(seq.select<Tout>((owned)fork2));
         }
 
         public virtual Enumerable<Tout> fork_many<Tout>(owned TransformDelegate<T, Enumerable<Tout>> fork1, owned TransformDelegate<T, Enumerable<Tout>> fork2) {
@@ -255,12 +255,12 @@ namespace Invercargill {
             });
         }
 
-        public virtual Enumerable<T> unique(owned EqualityDelegate<T> comparison) {
+        public virtual Enumerable<T> distinct(owned EqualityDelegate<T> comparison) {
             return new UniqueQuery<T>(this, (owned)comparison);
         }
 
         public virtual Enumerable<Grouping<TKey, T>> group_by<TKey>(TransformDelegate<T, TKey> key_selector, EqualityDelegate<TKey> key_equality) {
-            var keys = select<TKey>(i => key_selector(i)).unique((a, b) => key_equality(a, b));
+            var keys = select<TKey>(i => key_selector(i)).distinct((a, b) => key_equality(a, b));
             return keys.select<Grouping<TKey, T>>(g => new Grouping<TKey, T>(g, this.where(i => key_equality(g, key_selector(i)))));
         }
 
@@ -336,7 +336,7 @@ namespace Invercargill {
 
         public virtual string to_string(TransformDelegate<T, string> stringifier, string seperator = "") {
             bool is_first = true;
-            return aggrigate<string>("", (s, v) => {
+            return aggregate<string>("", (s, v) => {
                 if(is_first) {
                     is_first = false;
                     return stringifier(v);

src/lib/EnumerableProxy.vala

@@ -93,8 +93,8 @@ namespace Invercargill {
             return inner.contextualised_select((owned)transform);
         }
     
-        public override Tout aggrigate<Tout>(Tout initial, AggrigateDelegate<Tout, T> aggrigate_func) {
-            return inner.aggrigate(initial, aggrigate_func);
+        public override Tout aggregate<Tout>(Tout initial, AggregateDelegate<Tout, T> aggregate_func) {
+            return inner.aggregate(initial, aggregate_func);
         }
     
         public override T max(TransformDelegate<T, int> int_delegate) {
@@ -113,8 +113,8 @@ namespace Invercargill {
             return inner.pair(other);
         }
     
-        public override Enumerable<T> zip(Enumerable<T> other) {
-            return inner.zip(other);
+        public override Enumerable<T> interleave(Enumerable<T> other) {
+            return inner.interleave(other);
         }
     
         public override Enumerable<Tout> fork<Tout>(owned TransformDelegate<T, Tout> fork1, owned TransformDelegate<T, Tout> fork2) {

src/lib/Promotions/AttemptEnumerable.vala

@@ -162,12 +162,12 @@ namespace Invercargill {
             });
         }
     
-        public new Tout aggrigate<Tout>(Tout initial, AggrigateDelegate<Tout, T> aggrigate_func) throws Error {
-            var aggrigate = initial;
+        public new Tout aggregate<Tout>(Tout initial, AggregateDelegate<Tout, T> aggregate_func) throws Error {
+            var aggregate = initial;
             iterate(i => {
-                aggrigate = aggrigate_func(aggrigate, i);
+                aggregate = aggregate_func(aggregate, i);
             });
-            return aggrigate;
+            return aggregate;
         }
     
         public new T max(TransformDelegate<T, int> int_delegate) throws Error{

src/lib/Promotions/Numbers/NumberEnumerable.vala

@@ -16,7 +16,7 @@ namespace Invercargill {
             return divide(sum(), convert(count()));
         }
         public virtual T sum() {
-            return aggrigate<T>(zero(), add);
+            return aggregate<T>(zero(), add);
         }
         public virtual T product() {
             T number = zero();