Normalise generic names

src/lib/Attempt.vala

@@ -1,7 +1,7 @@
 namespace Invercargill {
 
     public delegate T AttemptDelegate<T>() throws Error;
-    public delegate Tout AttemptTransformDelegate<Tin, Tout>(Tin input) throws Error;
+    public delegate TOut AttemptTransformDelegate<TIn, TOut>(TIn input) throws Error;
 
     [Compact]
     [Immutable]

src/lib/Delegates.vala

@@ -2,15 +2,15 @@ namespace Invercargill {
 
     public delegate void ItemDelegate<T>(T item);
 
-    public delegate bool FilterTransformDelegate<Tin, Tout>(Tin item, ref Tout? res);
+    public delegate bool FilterTransformDelegate<TIn, TOut>(TIn item, ref TOut? res);
 
-    public delegate Tout TransformDelegate<Tin, Tout>(Tin item);
+    public delegate TOut TransformDelegate<TIn, TOut>(TIn item);
 
     public delegate TOut ZipperTransformDelegate<TFirst, TSecond, TOut>(TFirst? item1, bool item1_is_null, TSecond? item2, bool item2_is_null);
 
     public delegate bool PredicateDelegate<T>(T item);
 
-    public delegate Taggregate AggregateDelegate<Taggregate, Tin>(Taggregate aggregate, Tin item);
+    public delegate TAggregate AggregateDelegate<TAggregate, TIn>(TAggregate aggregate, TIn item);
 
     public delegate int CompareDelegate<T>(T a, T b);
 
@@ -22,9 +22,9 @@ namespace Invercargill {
 
     public delegate string StringifyDelegate<T>(T item);
 
-    public delegate Tout ErrorThrowingDelegate<Tin, Tout>(Tin item) throws Error;
+    public delegate TOut ErrorThrowingDelegate<TIn, TOut>(TIn item) throws Error;
 
-    public delegate Tout ErrorCatchingDelegate<Tin, Tout>(Tin item, Error error);
+    public delegate TOut ErrorCatchingDelegate<TIn, TOut>(TIn item, Error error);
 
     public delegate void DebugOutputDelegate(string output);
 

src/lib/Enumerable.vala

@@ -139,29 +139,29 @@ namespace Invercargill {
             return new Until<T>(this, (owned)predicate);
         }
 
-        public virtual Enumerable<Tout> select_where<Tout>(owned FilterTransformDelegate<T, Tout> transform) {
-            return new FilterTransform<T, Tout>(this, (owned)transform);
+        public virtual Enumerable<TOut> select_where<TOut>(owned FilterTransformDelegate<T, TOut> transform) {
+            return new FilterTransform<T, TOut>(this, (owned)transform);
         }
 
-        public virtual Enumerable<Tout> select<Tout>(owned TransformDelegate<T, Tout> transform) {
-            return new Transform<T, Tout>(this, (owned)transform);
+        public virtual Enumerable<TOut> select<TOut>(owned TransformDelegate<T, TOut> transform) {
+            return new Transform<T, TOut>(this, (owned)transform);
         }
 
-        public virtual Attempts<Tout> attempt_select<Tout>(owned AttemptTransformDelegate<T, Tout> transform) {
-            return select<Attempt<Tout>>(i => new Attempt<Tout>(() => transform(i))).assert_promotion<Attempts>();
+        public virtual Attempts<TOut> attempt_select<TOut>(owned AttemptTransformDelegate<T, TOut> transform) {
+            return select<Attempt<TOut>>(i => new Attempt<TOut>(() => transform(i))).assert_promotion<Attempts>();
         }
 
-        public virtual Attempts<SelectionContext<T, Tout>> attempt_contextualised_select<Tout>(owned AttemptTransformDelegate<T, Tout> transform) {
-            return attempt_select<SelectionContext<T, Tout>>((i) => new SelectionContext<T, Tout>() {
+        public virtual Attempts<SelectionContext<T, TOut>> attempt_contextualised_select<TOut>(owned AttemptTransformDelegate<T, TOut> transform) {
+            return attempt_select<SelectionContext<T, TOut>>((i) => new SelectionContext<T, TOut>() {
                 origin = i,
                 result = transform(i)
             });
         }
 
-        public virtual Attempts<Tout> attempt_select_nested<Tout>(owned AttemptTransformDelegate<T, Enumerable<Attempt<Tout>>> transform) {
-            return attempt_select<Enumerable<Attempt<Tout>>>((owned)transform)
+        public virtual Attempts<TOut> attempt_select_nested<TOut>(owned AttemptTransformDelegate<T, Enumerable<Attempt<TOut>>> transform) {
+            return attempt_select<Enumerable<Attempt<TOut>>>((owned)transform)
                 .as_enumerable()
-                .select_many<Attempt<Tout>>(a => a.success ? a.result : Invercargill.single<Attempt<Tout>>(new Attempt<Tout>.unsuccessful(a.error)))
+                .select_many<Attempt<TOut>>(a => a.success ? a.result : Invercargill.single<Attempt<TOut>>(new Attempt<TOut>.unsuccessful(a.error)))
                 .assert_promotion<Attempts>();
         }
 
@@ -169,8 +169,8 @@ namespace Invercargill {
             return select<Pair<TFirst, TSecond>>(i => new Pair<TFirst, TSecond>(transform1(i), true, transform2(i), true));
         }
 
-        public virtual Enumerable<Tout> select_many<Tout>(owned TransformDelegate<T, Enumerable<Tout>> transform) {
-            return new MergeQuery<Tout>(select((owned)transform));
+        public virtual Enumerable<TOut> select_many<TOut>(owned TransformDelegate<T, Enumerable<TOut>> transform) {
+            return new MergeQuery<TOut>(select((owned)transform));
         }
 
         public virtual Enumerable<T> sort(owned CompareDelegate<T> compare) {
@@ -204,16 +204,16 @@ namespace Invercargill {
             return new Skip<T>(this, count);
         }
 
-        public virtual Enumerable<Tout> cast<Tout>() {
-            return select<Tout>(i => (Tout)i);
+        public virtual Enumerable<TOut> cast<TOut>() {
+            return select<TOut>(i => (TOut)i);
         }
 
-        public virtual Enumerable<Tout> parallel_select<Tout>(owned TransformDelegate<T, Tout> transform, uint workers = 0) {
+        public virtual Enumerable<TOut> parallel_select<TOut>(owned TransformDelegate<T, TOut> transform, uint workers = 0) {
             var actual_workers = workers;
             if(actual_workers < 1) {
                 actual_workers = get_num_processors();
             }
-            return new Parallel<T, Tout>(this, (owned)transform, (int)actual_workers);
+            return new Parallel<T, TOut>(this, (owned)transform, (int)actual_workers);
         }
 
         public virtual void parallel_iterate(ItemDelegate<T> handler, uint workers = 0) {
@@ -224,14 +224,14 @@ namespace Invercargill {
             .iterate();
         }
 
-        public virtual Enumerable<SelectionContext<T, Tout>> contextualised_select<Tout>(owned TransformDelegate<T, Tout> transform) {
-            return select<SelectionContext<T, Tout>>((i) => new SelectionContext<T, Tout>() {
+        public virtual Enumerable<SelectionContext<T, TOut>> contextualised_select<TOut>(owned TransformDelegate<T, TOut> transform) {
+            return select<SelectionContext<T, TOut>>((i) => new SelectionContext<T, TOut>() {
                 origin = i,
                 result = transform(i)
             });
         }
 
-        public virtual Tout aggregate<Tout>(Tout initial, AggregateDelegate<Tout, T> aggregate_func) {
+        public virtual TOut aggregate<TOut>(TOut initial, AggregateDelegate<TOut, T> aggregate_func) {
             var aggregate = initial;
             iterate(i => {
                 aggregate = aggregate_func(aggregate, i);
@@ -290,21 +290,21 @@ namespace Invercargill {
             return new Zip<T, TOther, TOut>(this, other, (owned)transform);
         }
 
-        public virtual Enumerable<Pair<T, Tother>> pair_up<Tother>(Enumerable<Tother> other) {
-            return zip<Tother, Pair<T, Tother>>(other, (t1v, t1vs, t2v, t2vs) => new Pair<T, Tother>(t1v, t1vs, t2v, t2vs));
+        public virtual Enumerable<Pair<T, TOther>> pair_up<TOther>(Enumerable<TOther> other) {
+            return zip<TOther, Pair<T, TOther>>(other, (t1v, t1vs, t2v, t2vs) => new Pair<T, TOther>(t1v, t1vs, t2v, t2vs));
         }
 
         public virtual Enumerable<T> interleave(Enumerable<T> other) {
             return new Interleave<T>(this, other);
         }
 
-        public virtual Enumerable<Tout> fork<Tout>(owned TransformDelegate<T, Tout> fork1, owned TransformDelegate<T, Tout> fork2) {
+        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).interleave(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) {
-            return new MergeQuery<Tout>(fork((owned)fork1, (owned)fork2));
+        public virtual Enumerable<TOut> fork_many<TOut>(owned TransformDelegate<T, Enumerable<TOut>> fork1, owned TransformDelegate<T, Enumerable<TOut>> fork2) {
+            return new MergeQuery<TOut>(fork((owned)fork1, (owned)fork2));
         }
 
         public virtual bool matches(Enumerable<T> other, EqualityDelegate<T> equals) {
@@ -518,8 +518,8 @@ namespace Invercargill {
             return series;
         }
 
-        public virtual Attempts<Tout> attempt_map_with<Tout>(Mapper<Tout, T> mapper) {
-            return attempt_select<Tout>(o => mapper.materialise(o));
+        public virtual Attempts<TOut> attempt_map_with<TOut>(Mapper<TOut, T> mapper) {
+            return attempt_select<TOut>(o => mapper.materialise(o));
         }
 
         public virtual Enumerable<T> as_enumerable() {

src/lib/Invercargill.vala

@@ -15,7 +15,7 @@ namespace Invercargill {
         return seq;
     }
 
-    public static TransformDelegate<Tin, Tout> trycatch<Tin, Tout>(ErrorThrowingDelegate<Tin, Tout> main, ErrorCatchingDelegate<Tin, Tout> handler) {
+    public static TransformDelegate<TIn, TOut> trycatch<TIn, TOut>(ErrorThrowingDelegate<TIn, TOut> main, ErrorCatchingDelegate<TIn, TOut> handler) {
         return (i) => {
             try {
                 return main(i);
@@ -26,7 +26,7 @@ namespace Invercargill {
         };
     }
 
-    public static TransformDelegate<Tin, Tout> trydefault<Tin, Tout>(ErrorThrowingDelegate<Tin, Tout> func, Tout default_value) {
+    public static TransformDelegate<TIn, TOut> trydefault<TIn, TOut>(ErrorThrowingDelegate<TIn, TOut> func, TOut default_value) {
         return (i) => {
             try {
                 return func(i);

src/lib/Mapping/PropertyMapper.vala

@@ -5,8 +5,8 @@ namespace Invercargill.Mapping {
     public delegate bool PropertyPredicate<TClass>(TClass object);
     public delegate void PropertySetter<TClass, TProp>(TClass object, TProp value) throws Error;
     public delegate void PropertyDefaultSetter<TClass>(TClass object);
-    public delegate Tout PropertyGetterTransformer<Tin, Tout>(Tin object);
-    public delegate Tout PropertySetterTransformer<Tin, Tout>(Tin object) throws Error;
+    public delegate TOut PropertyGetterTransformer<TIn, TOut>(TIn object);
+    public delegate TOut PropertySetterTransformer<TIn, TOut>(TIn object) throws Error;
     public delegate T ObjectConstructor<T>();
     public class PropertyMapper<T> : Object, Mapper<T, Properties> {
 

src/lib/Modifiers/FilterTransform.vala

@@ -1,10 +1,10 @@
 namespace Invercargill.Modifiers {
 
-    public class FilterTransform<Tin, Tout> : Enumerable<Tout> {
-        private Enumerable<Tin> input;
-        private FilterTransformDelegate<Tin, Tout> transform_func;
+    public class FilterTransform<TIn, TOut> : Enumerable<TOut> {
+        private Enumerable<TIn> input;
+        private FilterTransformDelegate<TIn, TOut> transform_func;
 
-        public FilterTransform(Enumerable<Tin> input, owned FilterTransformDelegate<Tin, Tout> func) {
+        public FilterTransform(Enumerable<TIn> input, owned FilterTransformDelegate<TIn, TOut> func) {
             this.input = input;
             transform_func = (owned)func;
         }
@@ -17,13 +17,13 @@ namespace Invercargill.Modifiers {
             return new EnumerableInfo.infer_single(this, EnumerableCategory.COMPUTED, input);
         }
 
-        public override Tracker<Tout> get_tracker() {
+        public override Tracker<TOut> get_tracker() {
             var tracker = input.get_tracker();
 
-            return new AdvanceTracker<Tout>((out obj) => {
+            return new AdvanceTracker<TOut>((out obj) => {
                 while(tracker.has_next()) {
                     var item = tracker.get_next();
-                    Tout result = null;
+                    TOut result = null;
                     if(transform_func(item, ref result)){
                         obj = result;
                         return true;

src/lib/Modifiers/Parallel.vala

@@ -1,12 +1,12 @@
 using Invercargill.DataStructures;
 namespace Invercargill.Modifiers {
 
-    public class Parallel<Tin, Tout> : Enumerable<Tout>{
-        private TransformDelegate<Tin, Tout> transform_func;
-        private Enumerable<Tin> input;
+    public class Parallel<TIn, TOut> : Enumerable<TOut>{
+        private TransformDelegate<TIn, TOut> transform_func;
+        private Enumerable<TIn> input;
         private int workers;
 
-        public Parallel(Enumerable<Tin> input, owned TransformDelegate<Tin, Tout> transform, int workers) {
+        public Parallel(Enumerable<TIn> input, owned TransformDelegate<TIn, TOut> transform, int workers) {
             this.input = input;
             this.workers = workers;
             transform_func = (owned)transform;
@@ -20,22 +20,22 @@ namespace Invercargill.Modifiers {
             return new EnumerableInfo.infer_single(this, EnumerableCategory.COMPUTED, input);
         }
 
-        public override Tracker<Tout> get_tracker() {
-            return new ParallelTracker<Tin, Tout>(i => transform_func(i), workers, input.get_tracker());
+        public override Tracker<TOut> get_tracker() {
+            return new ParallelTracker<TIn, TOut>(i => transform_func(i), workers, input.get_tracker());
         }
     }
 
-    private class ParallelTracker<Tin, Tout> : Tracker<Tout> {
+    private class ParallelTracker<TIn, TOut> : Tracker<TOut> {
 
-        private Fifo<Tout> queue;
-        private Tracker<Tout> queue_tracker;
-        private TransformDelegate<Tin, Tout> transform_func;
-        private Tracker<Tin> input_tracker;
+        private Fifo<TOut> queue;
+        private Tracker<TOut> queue_tracker;
+        private TransformDelegate<TIn, TOut> transform_func;
+        private Tracker<TIn> input_tracker;
         private int remaining_workers;
 
-        public ParallelTracker(owned TransformDelegate<Tin, Tout> transform, int workers, Tracker<Tin> input) {
+        public ParallelTracker(owned TransformDelegate<TIn, TOut> transform, int workers, Tracker<TIn> input) {
             input_tracker = input;
-            queue = new Fifo<Tout>();
+            queue = new Fifo<TOut>();
             queue_tracker = queue.get_tracker();
             this.transform_func = (owned)transform;
 
@@ -45,9 +45,9 @@ namespace Invercargill.Modifiers {
             }
         }
 
-        private WorkerItem<Tin> next_for_worker() {
+        private WorkerItem<TIn> next_for_worker() {
             lock(input_tracker) {
-                var item = new WorkerItem<Tin>();
+                var item = new WorkerItem<TIn>();
                 if(input_tracker.has_next()) {
                     item.item = input_tracker.get_next();
                     return item;
@@ -78,12 +78,12 @@ namespace Invercargill.Modifiers {
         public override bool has_next() {
             return queue_tracker.has_next();
         }
-        public override Tout get_next() {
+        public override TOut get_next() {
             return queue_tracker.get_next();
         }
 
-        private class WorkerItem<Tin> {
-            public Tin? item { get; set; }
+        private class WorkerItem<TIn> {
+            public TIn? item { get; set; }
             public bool complete { get; set; }
         }
 

src/lib/Modifiers/Transform.vala

@@ -1,10 +1,10 @@
 namespace Invercargill.Modifiers {
 
-    public class Transform<Tin, Tout> : Enumerable<Tout> {
-        private Enumerable<Tin> input;
-        private TransformDelegate<Tin, Tout> transform_func;
+    public class Transform<TIn, TOut> : Enumerable<TOut> {
+        private Enumerable<TIn> input;
+        private TransformDelegate<TIn, TOut> transform_func;
 
-        public Transform(Enumerable<Tin> input, owned TransformDelegate<Tin, Tout> transform) {
+        public Transform(Enumerable<TIn> input, owned TransformDelegate<TIn, TOut> transform) {
             this.input = input;
             transform_func = (owned)transform;
         }
@@ -17,9 +17,9 @@ namespace Invercargill.Modifiers {
             return new EnumerableInfo.infer_single(this, EnumerableCategory.COMPUTED, input);
         }
 
-        public override Tracker<Tout> get_tracker() {
+        public override Tracker<TOut> get_tracker() {
             var tracker = input.get_tracker();
-            return new LambdaTracker<Tout>(
+            return new LambdaTracker<TOut>(
                 () => tracker.has_next(),
                 () => transform_func(tracker.get_next())
             );

src/lib/Promotions/Attempts.vala

@@ -142,30 +142,30 @@ namespace Invercargill {
             return inner.where(i => !i.success || predicate(i)).assert_promotion<Attempts<T>>();
         }
     
-        public new Attempts<Tout> select<Tout>(owned TransformDelegate<T, Tout> transform) {
-            return inner.select<Attempt<Tout>>(a => a.success ? new Attempt<Tout>.successful(transform(a.result)) : new Attempt<Tout>.unsuccessful(a.error)).assert_promotion<Attempts<T>>();
+        public new Attempts<TOut> select<TOut>(owned TransformDelegate<T, TOut> transform) {
+            return inner.select<Attempt<TOut>>(a => a.success ? new Attempt<TOut>.successful(transform(a.result)) : new Attempt<TOut>.unsuccessful(a.error)).assert_promotion<Attempts<T>>();
         }
     
-        public new Attempts<Tout> select_many<Tout>(owned TransformDelegate<T, Enumerable<Tout>> transform) {
-            return inner.select_many<Attempt<Tout>>(a => a.success ? transform(a.result).select<Attempt<Tout>>(i => new Attempt<Tout>.successful(i)) : Invercargill.single<Attempt<Tout>>(new Attempt<Tout>.unsuccessful(a.error))).assert_promotion<Attempts<T>>();
+        public new Attempts<TOut> select_many<TOut>(owned TransformDelegate<T, Enumerable<TOut>> transform) {
+            return inner.select_many<Attempt<TOut>>(a => a.success ? transform(a.result).select<Attempt<TOut>>(i => new Attempt<TOut>.successful(i)) : Invercargill.single<Attempt<TOut>>(new Attempt<TOut>.unsuccessful(a.error))).assert_promotion<Attempts<T>>();
         }
     
         public new Attempts<T> concat(Enumerable<Attempt<T>> other) {
             return inner.concat(other).assert_promotion<Attempts>();
         }
     
-        public new Attempts<Tout> cast<Tout>() {
-            return select<Tout>(i => (Tout)i);
+        public new Attempts<TOut> cast<TOut>() {
+            return select<TOut>(i => (TOut)i);
         }
     
-        public new Attempts<SelectionContext<T, Tout>> contextualised_select<Tout>(owned TransformDelegate<T, Tout> transform) {
-            return select<SelectionContext<T, Tout>>((i) => new SelectionContext<T, Tout>() {
+        public new Attempts<SelectionContext<T, TOut>> contextualised_select<TOut>(owned TransformDelegate<T, TOut> transform) {
+            return select<SelectionContext<T, TOut>>((i) => new SelectionContext<T, TOut>() {
                 origin = i,
                 result = transform(i)
             });
         }
     
-        public new Tout aggregate<Tout>(Tout initial, AggregateDelegate<Tout, T> aggregate_func) throws Error {
+        public new TOut aggregate<TOut>(TOut initial, AggregateDelegate<TOut, T> aggregate_func) throws Error {
             var aggregate = initial;
             iterate(i => {
                 aggregate = aggregate_func(aggregate, i);
@@ -227,23 +227,23 @@ namespace Invercargill {
             }
         }
     
-        public new Attempts<Tout> select_where<Tout>(owned FilterTransformDelegate<T, Tout> transform) {
-            return inner.select_where<Tout>((a, ref o) => !a.success || transform(a.result, ref o)).assert_promotion<Attempts<Tout>>();
+        public new Attempts<TOut> select_where<TOut>(owned FilterTransformDelegate<T, TOut> transform) {
+            return inner.select_where<TOut>((a, ref o) => !a.success || transform(a.result, ref o)).assert_promotion<Attempts<TOut>>();
         }
 
-        public new Attempts<Tout> attempt_select<Tout>(owned AttemptTransformDelegate<T, Tout> transform) {
-            return inner.attempt_select<Tout>(a => a.success ? new Attempt<Tout>(() => transform(a.result)) : new Attempt<Tout>.unsuccessful(a.error));
+        public new Attempts<TOut> attempt_select<TOut>(owned AttemptTransformDelegate<T, TOut> transform) {
+            return inner.attempt_select<TOut>(a => a.success ? new Attempt<TOut>(() => transform(a.result)) : new Attempt<TOut>.unsuccessful(a.error));
         }
 
-        public new Attempts<Tout> attempt_select_nested<Tout>(owned AttemptTransformDelegate<T, Enumerable<Attempt<Tout>>> transform) {
-            return attempt_select<Enumerable<Attempt<Tout>>>((owned)transform)
+        public new Attempts<TOut> attempt_select_nested<TOut>(owned AttemptTransformDelegate<T, Enumerable<Attempt<TOut>>> transform) {
+            return attempt_select<Enumerable<Attempt<TOut>>>((owned)transform)
                 .as_enumerable()
-                .select_many<Attempt<Tout>>(a => a.success ? a.result : Invercargill.single<Attempt<Tout>>(new Attempt<Tout>.unsuccessful(a.error)))
-                .assert_promotion<Attempts<Tout>>();
+                .select_many<Attempt<TOut>>(a => a.success ? a.result : Invercargill.single<Attempt<TOut>>(new Attempt<TOut>.unsuccessful(a.error)))
+                .assert_promotion<Attempts<TOut>>();
         }
 
-        public new Attempts<Tout> attempt_map_with<Tout>(Mapper<Tout, T> mapper) {
-            return attempt_select<Tout>(o => mapper.materialise(o));
+        public new Attempts<TOut> attempt_map_with<TOut>(Mapper<TOut, T> mapper) {
+            return attempt_select<TOut>(o => mapper.materialise(o));
         }
 
 

src/lib/Promotions/PropertyGroups.vala

@@ -17,8 +17,8 @@ namespace Invercargill {
             return element_type.is_a (typeof(Properties));
         }
 
-        public new Attempts<Tout> attempt_map_with<Tout>(PropertyMapper<Tout> mapper) {
-            return inner.attempt_map_with<Tout>(mapper);
+        public new Attempts<TOut> attempt_map_with<TOut>(PropertyMapper<TOut> mapper) {
+            return inner.attempt_map_with<TOut>(mapper);
         }
 
     }

src/lib/Proxy.vala

@@ -63,11 +63,11 @@ namespace Invercargill {
             return inner.where((owned)predicate);
         }
     
-        public override Enumerable<Tout> select<Tout>(owned TransformDelegate<T, Tout> transform) {
+        public override Enumerable<TOut> select<TOut>(owned TransformDelegate<T, TOut> transform) {
             return inner.select((owned)transform);
         }
     
-        public override Enumerable<Tout> select_many<Tout>(owned TransformDelegate<T, Enumerable<Tout>> transform) {
+        public override Enumerable<TOut> select_many<TOut>(owned TransformDelegate<T, Enumerable<TOut>> transform) {
             return inner.select_many((owned)transform);
         }
     
@@ -87,11 +87,11 @@ namespace Invercargill {
             return inner.skip(count);
         }
     
-        public override Enumerable<Tout> cast<Tout>() {
-            return inner.cast<Tout>();
+        public override Enumerable<TOut> cast<TOut>() {
+            return inner.cast<TOut>();
         }
     
-        public override Enumerable<Tout> parallel_select<Tout>(owned TransformDelegate<T, Tout> transform, uint workers = 0) {
+        public override Enumerable<TOut> parallel_select<TOut>(owned TransformDelegate<T, TOut> transform, uint workers = 0) {
             return inner.parallel_select((owned)transform, workers);
         }
     
@@ -99,11 +99,11 @@ namespace Invercargill {
             inner.parallel_iterate(handler, workers);
         }
     
-        public override Enumerable<SelectionContext<T, Tout>> contextualised_select<Tout>(owned TransformDelegate<T, Tout> transform) {
+        public override Enumerable<SelectionContext<T, TOut>> contextualised_select<TOut>(owned TransformDelegate<T, TOut> transform) {
             return inner.contextualised_select((owned)transform);
         }
     
-        public override Tout aggregate<Tout>(Tout initial, AggregateDelegate<Tout, T> aggregate_func) {
+        public override TOut aggregate<TOut>(TOut initial, AggregateDelegate<TOut, T> aggregate_func) {
             return inner.aggregate(initial, aggregate_func);
         }
     
@@ -119,7 +119,7 @@ namespace Invercargill {
             return inner.contains(item, equator);
         }
     
-        public override Enumerable<Pair<T, Tother>> pair_up<Tother>(Enumerable<Tother> other) {
+        public override Enumerable<Pair<T, TOther>> pair_up<TOther>(Enumerable<TOther> other) {
             return inner.pair_up(other);
         }
     
@@ -127,11 +127,11 @@ namespace Invercargill {
             return inner.interleave(other);
         }
     
-        public override Enumerable<Tout> fork<Tout>(owned TransformDelegate<T, Tout> fork1, owned TransformDelegate<T, Tout> fork2) {
+        public override Enumerable<TOut> fork<TOut>(owned TransformDelegate<T, TOut> fork1, owned TransformDelegate<T, TOut> fork2) {
             return inner.fork((owned)fork1, (owned)fork2);
         }
     
-        public override Enumerable<Tout> fork_many<Tout>(owned TransformDelegate<T, Enumerable<Tout>> fork1, owned TransformDelegate<T, Enumerable<Tout>> fork2) {
+        public override Enumerable<TOut> fork_many<TOut>(owned TransformDelegate<T, Enumerable<TOut>> fork1, owned TransformDelegate<T, Enumerable<TOut>> fork2) {
             return inner.fork_many((owned)fork1, (owned)fork2);
         }
     
@@ -219,24 +219,24 @@ namespace Invercargill {
             return inner.to_elements();
         }
 
-        public override Enumerable<Tout> select_where<Tout>(owned FilterTransformDelegate<T, Tout> transform) {
-            return inner.select_where<Tout>((owned)transform);
+        public override Enumerable<TOut> select_where<TOut>(owned FilterTransformDelegate<T, TOut> transform) {
+            return inner.select_where<TOut>((owned)transform);
         }
 
-        public override Attempts<Tout> attempt_select<Tout>(owned AttemptTransformDelegate<T, Tout> transform) {
-            return inner.attempt_select<Tout>((owned)transform);
+        public override Attempts<TOut> attempt_select<TOut>(owned AttemptTransformDelegate<T, TOut> transform) {
+            return inner.attempt_select<TOut>((owned)transform);
         }
 
-        public override Attempts<Tout> attempt_select_nested<Tout>(owned AttemptTransformDelegate<T, Enumerable<Attempt<Tout>>> transform) {
-            return inner.attempt_select_nested<Tout>((owned)transform);
+        public override Attempts<TOut> attempt_select_nested<TOut>(owned AttemptTransformDelegate<T, Enumerable<Attempt<TOut>>> transform) {
+            return inner.attempt_select_nested<TOut>((owned)transform);
         }   
 
         public override Enumerable<T> cache() {
             return inner.cache();
         }
 
-        public override Attempts<Tout> attempt_map_with<Tout>(Mapper<Tout, T> mapper) {
-            return inner.attempt_map_with<Tout>(mapper);
+        public override Attempts<TOut> attempt_map_with<TOut>(Mapper<TOut, T> mapper) {
+            return inner.attempt_map_with<TOut>(mapper);
         }
         
         public override Enumerable<T> as_enumerable() {