diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/control/FluxSource.java b/cyclops-reactor/src/main/java/com/aol/cyclops/control/FluxSource.java
index 66b81709..987d4cc1 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/control/FluxSource.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/control/FluxSource.java
@@ -1,6 +1,5 @@
 package com.aol.cyclops.control;
 
-
 import java.util.Objects;
 import java.util.stream.Stream;
 
@@ -37,8 +36,8 @@ public class FluxSource {
      */
     public static <T> MultipleFluxSource<T> ofMultiple() {
         return new MultipleFluxSource<T>(
-                                           FluxSource.ofUnbounded()
-                                                       .createQueue());
+                                         FluxSource.ofUnbounded()
+                                                   .createQueue());
     }
 
     /**
@@ -46,8 +45,8 @@ public static <T> MultipleFluxSource<T> ofMultiple() {
      */
     public static <T> MultipleFluxSource<T> ofMultiple(int backPressureAfter) {
         return new MultipleFluxSource<T>(
-                                           FluxSource.of(backPressureAfter)
-                                                       .createQueue());
+                                         FluxSource.of(backPressureAfter)
+                                                   .createQueue());
     }
 
     /**
@@ -56,8 +55,8 @@ public static <T> MultipleFluxSource<T> ofMultiple(int backPressureAfter) {
     public static <T> MultipleFluxSource<T> ofMultiple(QueueFactory<?> q) {
         Objects.requireNonNull(q);
         return new MultipleFluxSource<T>(
-                                           FluxSource.of(q)
-                                                       .createQueue());
+                                         FluxSource.of(q)
+                                                   .createQueue());
     }
 
     /**
@@ -116,7 +115,7 @@ public static FluxSource of(int backPressureAfter) {
             throw new IllegalArgumentException(
                                                "Can't apply back pressure after less than 1 event");
         return new FluxSource(
-                                backPressureAfter, true);
+                              backPressureAfter, true);
     }
 
     <T> Queue<T> createQueue() {
@@ -176,6 +175,7 @@ public <T> PushableStream<T> stream() {
                                      q, (Stream) q.stream());
 
     }
+
     /**
      * Create a pushable Flux
      * 
@@ -185,8 +185,9 @@ public <T> PushableStream<T> stream() {
     public <T> PushableFlux<T> flux() {
         Queue<T> q = createQueue();
         return new PushableFlux<T>(
-                                          q, Flux.from(q.stream()));
+                                   q, Flux.from(q.stream()));
     }
+
     /**
      * Create a pushable ReactiveSeq
      * 
@@ -220,6 +221,7 @@ public static <T> ReactiveSeq<T> reactiveSeq(Adapter<T> adapter) {
 
         return adapter.stream();
     }
+
     /**
      * Create a pushable ReactiveSeq
      * 
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/control/Publishers.java b/cyclops-reactor/src/main/java/com/aol/cyclops/control/Publishers.java
index bd07c797..b609fea9 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/control/Publishers.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/control/Publishers.java
@@ -10,7 +10,6 @@
 
 import reactor.core.publisher.Flux;
 
-
 /**
  * Utilities for working with reactive-streams Publishers
  * 
@@ -39,26 +38,26 @@ public class Publishers {
     public static <T> AnyMSeq<T> anyM(Publisher<T> flux) {
         return AnyM.ofSeq(flux);
     }
-   
+
     /**
      * Convert a reactive-streams Publisher to a cyclops-react ReactiveSeq extended Stream type
      * 
      * @param pub Publisher to convert to a Stream
      * @return ReactiveSeq
      */
-    public static<T> ReactiveSeq<T> stream(Publisher<T> pub){
+    public static <T> ReactiveSeq<T> stream(Publisher<T> pub) {
         return ReactiveSeq.fromStream(jdkStream(pub));
     }
-    
+
     /**
      * Convert a reactive-streams Publisher to a plain java.util.Stream
      * 
      * @param pub Publisher to convert to a Stream
      * @return Stream
      */
-    public static<T> Stream<T> jdkStream(Publisher<T> pub){
+    public static <T> Stream<T> jdkStream(Publisher<T> pub) {
         SeqSubscriber<T> sub = SeqSubscriber.subscriber();
         pub.subscribe(sub);
-        return StreamSupport.stream(sub.spliterator(),false);
+        return StreamSupport.stream(sub.spliterator(), false);
     }
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/control/ReactorPipes.java b/cyclops-reactor/src/main/java/com/aol/cyclops/control/ReactorPipes.java
index 8269b343..b0b98f1e 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/control/ReactorPipes.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/control/ReactorPipes.java
@@ -1,6 +1,5 @@
 package com.aol.cyclops.control;
 
-
 import static org.hamcrest.Matchers.equalTo;
 import static org.junit.Assert.assertThat;
 
@@ -45,7 +44,6 @@ public class ReactorPipes<K, V> {
 
     private final ConcurrentMap<K, Adapter<V>> registered = new ConcurrentHashMap<>();
 
-   
     /**
      * @return Size of registered pipes
      */
@@ -133,6 +131,7 @@ public Maybe<LazyFutureStream<V>> futureStream(final K key, final LazyReact reac
     public Maybe<ReactiveSeq<V>> reactiveSeq(final K key) {
         return get(key).map(a -> a.stream());
     }
+
     /**
      * @param key : Adapter identifier
      * @return LazyFutureStream from selected Queue
@@ -147,8 +146,7 @@ public LazyListX<V> xValues(final K key, final long x) {
         return get(key).peek(a -> a.stream()
                                    .subscribe(sub))
                        .map(a -> LazyListX.fromStreamS(sub.stream()
-                                    .limit(x))
-                                    )
+                                                          .limit(x)))
                        .orElse(LazyListX.empty());
     }
 
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/FluxTs.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/FluxTs.java
index 815d1a8e..1c2c5c8c 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/FluxTs.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/FluxTs.java
@@ -25,7 +25,7 @@
  */
 @UtilityClass
 public class FluxTs {
-    
+
     /**
      * Construct an AnyM type from a Flux. This allows the Flux to be manipulated according to a standard interface
      * along with a vast array of other Java Monad implementations
@@ -47,7 +47,6 @@ public static <T> AnyMSeq<T> anyM(FluxT<T> flux) {
         return AnyM.ofSeq(flux);
     }
 
-   
     /**
      * Construct a FluxT from a Publisher containing Fluxes.
      * 
@@ -91,24 +90,23 @@ public static <T> FluxTSeq<T> fluxT(Publisher<Flux<T>> nested) {
     * @param yieldingFunction  Generates a result per combination
     * @return FluxT with an element per combination of nested publishers generated by the yielding function
     */
-   public static <T1, T2, T3, R1, R2, R3, R> FluxT<R> forEach(FluxT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
-           QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
+    public static <T1, T2, T3, R1, R2, R3, R> FluxT<R> forEach(FluxT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
+            QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
-                            .yield4(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
+                             .yield4(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
-  
+    }
 
-   /**
+    /**
     * Perform a For Comprehension over a FluxT, accepting 3 generating functions. 
     * This results in a four level nested internal iteration over the provided Publishers.
     * 
@@ -129,9 +127,9 @@ public static <T1, T2, T3, R1, R2, R3, R> FluxT<R> forEach(FluxT<? extends T1> v
               
     //(10, 10, 10, 10)
       (11, 11, 11, 11)       
-   * 
-   * }
-   * </pre>
+    * 
+    * }
+    * </pre>
     * @param value1 top level FluxT
     * @param value2 Nested publisher
     * @param value3 Nested publisher
@@ -140,24 +138,25 @@ public static <T1, T2, T3, R1, R2, R3, R> FluxT<R> forEach(FluxT<? extends T1> v
     * @param yieldingFunction Generates a result per combination
     * @return FluxT with an element per combination of nested publishers generated by the yielding function
     */
-   public static <T1, T2, T3, R1, R2, R3, R> FluxT<R> forEach(FluxT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
-           QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, Boolean> filterFunction,
-           QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
+    public static <T1, T2, T3, R1, R2, R3, R> FluxT<R> forEach(FluxT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
+            QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, Boolean> filterFunction,
+            QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
-                            .filter(a -> b -> c -> d -> filterFunction.apply(a, b, c, d))
-                            .yield4(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
+                             .filter(a -> b -> c -> d -> filterFunction.apply(a, b, c, d))
+                             .yield4(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
-   /**
+    }
+
+    /**
     * Perform a For Comprehension over a FluxT, accepting 2 generating functions. 
     * This results in three level nested internal iteration over the provided Publishers.
     * 
@@ -175,30 +174,31 @@ public static <T1, T2, T3, R1, R2, R3, R> FluxT<R> forEach(FluxT<? extends T1> v
               .forEach(System.out::println);
               
          
-   * 
-   * }
-   * </pre>
-   * 
-   * @param value1 top level FluxT
-   * @param value2 Nested publisher
-   * @param value3 Nested publisher
-   * @param yieldingFunction  Generates a result per combination
-   * @return FluxT with an element per combination of nested publishers generated by the yielding function
-   */
-   public static <T1, T2, R1, R2, R> FluxT<R> forEach(FluxT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+    * 
+    * }
+    * </pre>
+    * 
+    * @param value1 top level FluxT
+    * @param value2 Nested publisher
+    * @param value3 Nested publisher
+    * @param yieldingFunction  Generates a result per combination
+    * @return FluxT with an element per combination of nested publishers generated by the yielding function
+    */
+    public static <T1, T2, R1, R2, R> FluxT<R> forEach(FluxT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .yield3(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .yield3(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+    }
 
-   }
-   /**
+    /**
     * Perform a For Comprehension over a FluxT, accepting 2 generating functions. 
     * This results in a three level nested internal iteration over the provided Publishers.
     * 
@@ -215,10 +215,10 @@ public static <T1, T2, R1, R2, R> FluxT<R> forEach(FluxT<? extends T1> value1,
                  (a,b,c)->a+b+c<102,
               Tuple::tuple)
               .forEach(System.out::println);
-
-   * 
-   * }
-   * </pre>
+    
+    * 
+    * }
+    * </pre>
     * @param value1 top level FluxT
     * @param value2 Nested publisher
     * @param value3 Nested publisher
@@ -226,60 +226,61 @@ public static <T1, T2, R1, R2, R> FluxT<R> forEach(FluxT<? extends T1> value1,
     * @param yieldingFunction Generates a result per combination
     * @return FluxT with an element per combination of nested publishers generated by the yielding function
     */
-  public  static <T1, T2, R1, R2, R> FluxT<R> forEach(FluxT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, Boolean> filterFunction,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+    public static <T1, T2, R1, R2, R> FluxT<R> forEach(FluxT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, Boolean> filterFunction,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .filter(a -> b -> c -> filterFunction.apply(a, b, c))
-                            .yield3(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .filter(a -> b -> c -> filterFunction.apply(a, b, c))
+                             .yield3(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
+    }
 
-  /**
-   * Perform a For Comprehension over a FluxT, accepting a generating function. 
-   * This results in two level nested internal iteration over the provided Publishers.
-   * 
-   *  <pre>
-   * {@code
-   *    
-   *   import static com.aol.cyclops.reactor.FluxTs.forEach;
-   *   
-   *    FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
-   *    
+    /**
+     * Perform a For Comprehension over a FluxT, accepting a generating function. 
+     * This results in two level nested internal iteration over the provided Publishers.
+     * 
+     *  <pre>
+     * {@code
+     *    
+     *   import static com.aol.cyclops.reactor.FluxTs.forEach;
+     *   
+     *    FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
+     *    
        forEach(fluxT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
              Tuple::tuple)
              .forEach(System.out::println);
              
         
-  * 
-  * }
-  * </pre>
-  * 
-  * @param value1 top level FluxT
-  * @param value2 Nested publisher
-  * @param value3 Nested publisher
-  * @param yieldingFunction  Generates a result per combination
-  * @return FluxT with an element per combination of nested publishers generated by the yielding function
-  */
-   public static <T, R1, R> FluxT<R> forEach(FluxT<? extends T> value1, Function<? super T, Publisher<R1>> value2,
-           BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+    * 
+    * }
+    * </pre>
+    * 
+    * @param value1 top level FluxT
+    * @param value2 Nested publisher
+    * @param value3 Nested publisher
+    * @param yieldingFunction  Generates a result per combination
+    * @return FluxT with an element per combination of nested publishers generated by the yielding function
+    */
+    public static <T, R1, R> FluxT<R> forEach(FluxT<? extends T> value1, Function<? super T, Publisher<R1>> value2,
+            BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .yield2(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .yield2(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+    }
 
-   }
-   /**
+    /**
     * Perform a For Comprehension over a FluxT, accepting a generating function. 
     * This results in a two level nested internal iteration over the provided Publishers.
     * 
@@ -295,10 +296,10 @@ public static <T, R1, R> FluxT<R> forEach(FluxT<? extends T> value1, Function<?
                  (a,b)->a+b<102,
               Tuple::tuple)
               .forEach(System.out::println);
-
-   * 
-   * }
-   * </pre>
+    
+    * 
+    * }
+    * </pre>
     * @param value1 top level FluxT
     * @param value2 Nested publisher
     * @param value3 Nested publisher
@@ -306,17 +307,18 @@ public static <T, R1, R> FluxT<R> forEach(FluxT<? extends T> value1, Function<?
     * @param yieldingFunction Generates a result per combination
     * @return FluxT with an element per combination of nested publishers generated by the yielding function
     */
-   public static <T, R1, R> FluxT<R> forEach(FluxT<? extends T> value1, Function<? super T, ? extends Publisher<R1>> value2,
-           BiFunction<? super T, ? super R1, Boolean> filterFunction,
-           BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+    public static <T, R1, R> FluxT<R> forEach(FluxT<? extends T> value1,
+            Function<? super T, ? extends Publisher<R1>> value2,
+            BiFunction<? super T, ? super R1, Boolean> filterFunction,
+            BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .filter(a -> b -> filterFunction.apply(a, b))
-                            .yield2(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .filter(a -> b -> filterFunction.apply(a, b))
+                             .yield2(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
+    }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Fluxes.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Fluxes.java
index c09364a7..65d037c4 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Fluxes.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Fluxes.java
@@ -914,7 +914,7 @@ public T next() {
      * @return Non-empty Flux
      */
     public static <T> Flux<T> onEmpty(Flux<T> flux, T value) {
-       
+
         return Flux.fromIterable(() -> new Iterator<T>() {
 
             Iterator<T> it;
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/MonoTs.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/MonoTs.java
index 95639ccc..adc3ecf7 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/MonoTs.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/MonoTs.java
@@ -26,7 +26,7 @@
  */
 @UtilityClass
 public class MonoTs {
-    
+
     /**
      * Construct an AnyM type from a Mono. This allows the Mono to be manipulated according to a standard interface
      * along with a vast array of other Java Monad implementations
@@ -48,7 +48,6 @@ public static <T> AnyMSeq<T> anyM(MonoT<T> mono) {
         return AnyM.ofSeq(mono);
     }
 
-   
     /**
      * Construct a MonoT from a Publisher containing Monos.
      * 
@@ -92,24 +91,23 @@ public static <T> MonoTSeq<T> monoT(Publisher<Mono<T>> nested) {
     * @param yieldingFunction  Generates a result per combination
     * @return MonoTSeq with an element per combination of nested publishers generated by the yielding function
     */
-   public static <T1, T2, T3, R1, R2, R3, R> MonoT<R> forEach(MonoT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
-           QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
+    public static <T1, T2, T3, R1, R2, R3, R> MonoT<R> forEach(MonoT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
+            QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
-                            .yield4(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
+                             .yield4(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
-  
+    }
 
-   /**
+    /**
     * Perform a For Comprehension over a MonoT, accepting 3 generating functions. 
     * This results in a four level nested internal iteration over the provided Publishers.
     * 
@@ -130,9 +128,9 @@ public static <T1, T2, T3, R1, R2, R3, R> MonoT<R> forEach(MonoT<? extends T1> v
               
     //(10, 10, 10, 10)
       (11, 11, 11, 11)       
-   * 
-   * }
-   * </pre>
+    * 
+    * }
+    * </pre>
     * @param value1 top level MonoT
     * @param value2 Nested publisher
     * @param value3 Nested publisher
@@ -141,24 +139,25 @@ public static <T1, T2, T3, R1, R2, R3, R> MonoT<R> forEach(MonoT<? extends T1> v
     * @param yieldingFunction Generates a result per combination
     * @return
     */
-   public static <T1, T2, T3, R1, R2, R3, R> MonoT<R> forEach(MonoT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
-           QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, Boolean> filterFunction,
-           QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
+    public static <T1, T2, T3, R1, R2, R3, R> MonoT<R> forEach(MonoT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends Publisher<R3>> value4,
+            QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, Boolean> filterFunction,
+            QuadFunction<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
-                            .filter(a -> b -> c -> d -> filterFunction.apply(a, b, c, d))
-                            .yield4(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .anyM(a -> b -> c -> Publishers.anyM(value4.apply(a, b, c)))
+                             .filter(a -> b -> c -> d -> filterFunction.apply(a, b, c, d))
+                             .yield4(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
-   /**
+    }
+
+    /**
     * Perform a For Comprehension over a MonoT, accepting 2 generating functions. 
     * This results in three level nested internal iteration over the provided Publishers.
     * 
@@ -176,30 +175,31 @@ public static <T1, T2, T3, R1, R2, R3, R> MonoT<R> forEach(MonoT<? extends T1> v
               .forEach(System.out::println);
               
          
-   * 
-   * }
-   * </pre>
-   * 
-   * @param value1 top level MonoT
-   * @param value2 Nested publisher
-   * @param value3 Nested publisher
-   * @param yieldingFunction  Generates a result per combination
-   * @return MonoTSeq with an element per combination of nested publishers generated by the yielding function
-   */
-   public static <T1, T2, R1, R2, R> MonoT<R> forEach(MonoT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+    * 
+    * }
+    * </pre>
+    * 
+    * @param value1 top level MonoT
+    * @param value2 Nested publisher
+    * @param value3 Nested publisher
+    * @param yieldingFunction  Generates a result per combination
+    * @return MonoTSeq with an element per combination of nested publishers generated by the yielding function
+    */
+    public static <T1, T2, R1, R2, R> MonoT<R> forEach(MonoT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .yield3(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .yield3(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+    }
 
-   }
-   /**
+    /**
     * Perform a For Comprehension over a MonoT, accepting 2 generating functions. 
     * This results in a three level nested internal iteration over the provided Publishers.
     * 
@@ -216,10 +216,10 @@ public static <T1, T2, R1, R2, R> MonoT<R> forEach(MonoT<? extends T1> value1,
                  (a,b,c,d)->a+b+c+d<102,
               Tuple::tuple)
               .forEach(System.out::println);
-
-   * 
-   * }
-   * </pre>
+    
+    * 
+    * }
+    * </pre>
     * @param value1 top level MonoT
     * @param value2 Nested publisher
     * @param value3 Nested publisher
@@ -227,60 +227,61 @@ public static <T1, T2, R1, R2, R> MonoT<R> forEach(MonoT<? extends T1> value1,
     * @param yieldingFunction Generates a result per combination
     * @return MonoTSeq with an element per combination of nested publishers generated by the yielding function
     */
-  public  static <T1, T2, R1, R2, R> MonoT<R> forEach(MonoT<? extends T1> value1,
-           Function<? super T1, ? extends Publisher<R1>> value2,
-           BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
-           TriFunction<? super T1, ? super R1, ? super R2, Boolean> filterFunction,
-           TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+    public static <T1, T2, R1, R2, R> MonoT<R> forEach(MonoT<? extends T1> value1,
+            Function<? super T1, ? extends Publisher<R1>> value2,
+            BiFunction<? super T1, ? super R1, ? extends Publisher<R2>> value3,
+            TriFunction<? super T1, ? super R1, ? super R2, Boolean> filterFunction,
+            TriFunction<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
-                            .filter(a -> b -> c -> filterFunction.apply(a, b, c))
-                            .yield3(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .anyM(a -> b -> Publishers.anyM(value3.apply(a, b)))
+                             .filter(a -> b -> c -> filterFunction.apply(a, b, c))
+                             .yield3(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
+    }
 
-  /**
-   * Perform a For Comprehension over a MonoT, accepting a generating function. 
-   * This results in two level nested internal iteration over the provided Publishers.
-   * 
-   *  <pre>
-   * {@code
-   *    
-   *   import static com.aol.cyclops.reactor.MonoTs.forEach;
-   *   
-   *    MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
-   *    
+    /**
+     * Perform a For Comprehension over a MonoT, accepting a generating function. 
+     * This results in two level nested internal iteration over the provided Publishers.
+     * 
+     *  <pre>
+     * {@code
+     *    
+     *   import static com.aol.cyclops.reactor.MonoTs.forEach;
+     *   
+     *    MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
+     *    
        forEach(monoT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
              Tuple::tuple)
              .forEach(System.out::println);
              
         
-  * 
-  * }
-  * </pre>
-  * 
-  * @param value1 top level MonoT
-  * @param value2 Nested publisher
-  * @param value3 Nested publisher
-  * @param yieldingFunction  Generates a result per combination
-  * @return MonoTSeq with an element per combination of nested publishers generated by the yielding function
-  */
-   public static <T, R1, R> MonoT<R> forEach(MonoT<? extends T> value1, Function<? super T, Publisher<R1>> value2,
-           BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+    * 
+    * }
+    * </pre>
+    * 
+    * @param value1 top level MonoT
+    * @param value2 Nested publisher
+    * @param value3 Nested publisher
+    * @param yieldingFunction  Generates a result per combination
+    * @return MonoTSeq with an element per combination of nested publishers generated by the yielding function
+    */
+    public static <T, R1, R> MonoT<R> forEach(MonoT<? extends T> value1, Function<? super T, Publisher<R1>> value2,
+            BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .yield2(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .yield2(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+    }
 
-   }
-   /**
+    /**
     * Perform a For Comprehension over a MonoT, accepting a generating function. 
     * This results in a two level nested internal iteration over the provided Publishers.
     * 
@@ -296,10 +297,10 @@ public static <T, R1, R> MonoT<R> forEach(MonoT<? extends T> value1, Function<?
                  (a,b,c,d)->a+b+c+d<102,
               Tuple::tuple)
               .forEach(System.out::println);
-
-   * 
-   * }
-   * </pre>
+    
+    * 
+    * }
+    * </pre>
     * @param value1 top level MonoT
     * @param value2 Nested publisher
     * @param value3 Nested publisher
@@ -307,17 +308,18 @@ public static <T, R1, R> MonoT<R> forEach(MonoT<? extends T> value1, Function<?
     * @param yieldingFunction Generates a result per combination
     * @return MonoTSeq with an element per combination of nested publishers generated by the yielding function
     */
-   public static <T, R1, R> MonoT<R> forEach(MonoT<? extends T> value1, Function<? super T, ? extends Publisher<R1>> value2,
-           BiFunction<? super T, ? super R1, Boolean> filterFunction,
-           BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+    public static <T, R1, R> MonoT<R> forEach(MonoT<? extends T> value1,
+            Function<? super T, ? extends Publisher<R1>> value2,
+            BiFunction<? super T, ? super R1, Boolean> filterFunction,
+            BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
 
-       return AnyM.ofSeq(For.anyM(anyM(value1))
-                            .anyM(a -> Publishers.anyM(value2.apply(a)))
-                            .filter(a -> b -> filterFunction.apply(a, b))
-                            .yield2(yieldingFunction)
-                            .unwrap())
-                  .unwrap();
+        return AnyM.ofSeq(For.anyM(anyM(value1))
+                             .anyM(a -> Publishers.anyM(value2.apply(a)))
+                             .filter(a -> b -> filterFunction.apply(a, b))
+                             .yield2(yieldingFunction)
+                             .unwrap())
+                   .unwrap();
 
-   }
+    }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Monos.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Monos.java
index 7046a43f..b28ecc2b 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Monos.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/Monos.java
@@ -48,7 +48,7 @@ public class Monos {
     public static <T> AnyMValue<T> mono(Mono<T> mono) {
         return AnyM.ofValue(mono);
     }
-    
+
     /**
      * Perform a For Comprehension over a Mono, accepting 3 generating functions. 
      * This results in a four level nested internal iteration over the provided Monos.
@@ -172,6 +172,7 @@ public static <T1, T2, R1, R2, R> Mono<R> forEach(Mono<? extends T1> value1,
                    .unwrap();
 
     }
+
     /**
      * 
      * Perform a For Comprehension over a Mono, accepting 2 generating functions. 
@@ -213,6 +214,7 @@ public static <T1, T2, R1, R2, R> Mono<R> forEach(Mono<? extends T1> value1,
                    .unwrap();
 
     }
+
     /**
      * Perform a For Comprehension over a Mono, accepting a generating function. 
      * This results in a two level nested internal iteration over the provided Monos.
@@ -244,6 +246,7 @@ public static <T, R1, R> Mono<R> forEach(Mono<? extends T> value1, Function<? su
                    .unwrap();
 
     }
+
     /**
      * 
      * Perform a For Comprehension over a Mono, accepting a generating functions. 
@@ -281,7 +284,7 @@ public static <T, R1, R> Mono<R> forEach(Mono<? extends T> value1, Function<? su
                    .unwrap();
 
     }
-    
+
     /**
      * Lazily combine this Mono with the supplied value via the supplied BiFunction
      * 
@@ -290,9 +293,12 @@ public static <T, R1, R> Mono<R> forEach(Mono<? extends T> value1, Function<? su
      * @param fn Combiner function
      * @return Combined Mono
      */
-    public static <T1,T2,R> Mono<R> combine(Mono<? extends T1> mono,Value<? extends T2> app, BiFunction<? super T1, ? super T2, ? extends R> fn){
-        return  Mono.from(FutureW.of(mono.toFuture()).combine(app, fn));
+    public static <T1, T2, R> Mono<R> combine(Mono<? extends T1> mono, Value<? extends T2> app,
+            BiFunction<? super T1, ? super T2, ? extends R> fn) {
+        return Mono.from(FutureW.of(mono.toFuture())
+                                .combine(app, fn));
     }
+
     /**
      * Lazily combine this Mono with the supplied Mono via the supplied BiFunction
      * 
@@ -301,9 +307,12 @@ public static <T1,T2,R> Mono<R> combine(Mono<? extends T1> mono,Value<? extends
      * @param fn Combiner function
      * @return Combined Mono
      */
-    public static <T1,T2,R> Mono<R> combine(Mono<? extends T1> mono,Mono<? extends T2> app, BiFunction<? super T1, ? super T2, ? extends R> fn){
-        return  Mono.from(FutureW.of(mono.toFuture()).combine(FutureW.of(app.toFuture()), fn));
+    public static <T1, T2, R> Mono<R> combine(Mono<? extends T1> mono, Mono<? extends T2> app,
+            BiFunction<? super T1, ? super T2, ? extends R> fn) {
+        return Mono.from(FutureW.of(mono.toFuture())
+                                .combine(FutureW.of(app.toFuture()), fn));
     }
+
     /**
      * Combine the provided Mono with the first element (if present) in the provided Iterable using the provided BiFunction
      * 
@@ -312,9 +321,12 @@ public static <T1,T2,R> Mono<R> combine(Mono<? extends T1> mono,Mono<? extends T
      * @param fn Combining function
      * @return Combined Mono
      */
-    public static <T1,T2,R> Mono<R> zip(Mono<? extends T1> mono,Iterable<? extends T2> app, BiFunction<? super T1, ? super T2, ? extends R> fn){
-        return  Mono.from(FutureW.of(mono.toFuture()).zip(app, fn));
+    public static <T1, T2, R> Mono<R> zip(Mono<? extends T1> mono, Iterable<? extends T2> app,
+            BiFunction<? super T1, ? super T2, ? extends R> fn) {
+        return Mono.from(FutureW.of(mono.toFuture())
+                                .zip(app, fn));
     }
+
     /**
      * Combine the provided Mono with the first element (if present) in the provided Publisher using the provided BiFunction
      * 
@@ -323,9 +335,12 @@ public static <T1,T2,R> Mono<R> zip(Mono<? extends T1> mono,Iterable<? extends T
      * @param app Combining function
      * @return Combined Mono
      */
-    public static <T1,T2,R> Mono<R> zip(Mono<? extends T1> mono,BiFunction<? super T1, ? super T2, ? extends R> fn, Publisher<? extends T2> app){
-        return  Mono.from(FutureW.of(mono.toFuture()).zip(fn,app));
+    public static <T1, T2, R> Mono<R> zip(Mono<? extends T1> mono, BiFunction<? super T1, ? super T2, ? extends R> fn,
+            Publisher<? extends T2> app) {
+        return Mono.from(FutureW.of(mono.toFuture())
+                                .zip(fn, app));
     }
+
     /**
      * Test if value is equal to the value inside this Mono
      * 
@@ -333,27 +348,29 @@ public static <T1,T2,R> Mono<R> zip(Mono<? extends T1> mono,BiFunction<? super T
      * @param test Value to test
      * @return true if equal
      */
-    public static <T> boolean test(Mono<T> mono,T test){
-        return  FutureW.of(mono.toFuture()).test(test);
+    public static <T> boolean test(Mono<T> mono, T test) {
+        return FutureW.of(mono.toFuture())
+                      .test(test);
     }
-    
+
     /**
      * Construct a Mono from Iterable by taking the first value from Iterable
      * 
      * @param t Iterable to populate Mono from
      * @return Mono containing first element from Iterable (or empty Mono)
      */
-    public static <T> Mono<T> fromIterable(Iterable<T> t){
+    public static <T> Mono<T> fromIterable(Iterable<T> t) {
         return Mono.from(Flux.fromIterable(t));
     }
+
     /**
      * Get an Iterator for the value (if any) in the provided Mono
      * 
      * @param pub Mono to get Iterator for
      * @return Iterator over Mono value
      */
-    public static<T> Iterator<T> iterator(Mono<T> pub){
-     
+    public static <T> Iterator<T> iterator(Mono<T> pub) {
+
         ValueSubscriber<T> sub = ValueSubscriber.subscriber();
         pub.subscribe(sub);
         return sub.iterator();
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/AbstractFluentCollectionX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/AbstractFluentCollectionX.java
index 1c82a0f6..41fa2c99 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/AbstractFluentCollectionX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/AbstractFluentCollectionX.java
@@ -93,8 +93,11 @@ public C get() {
 
         }
 
-        /* (non-Javadoc)
-         * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollection#stream()
+        /*
+         * (non-Javadoc)
+         * 
+         * @see com.aol.cyclops.reactor.collections.extensions.base.
+         * LazyFluentCollection#stream()
          */
         @Override
         public Flux<T> flux() {
@@ -104,20 +107,30 @@ public Flux<T> flux() {
         }
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.types.ReactorConvertable#flux()
      */
     @Override
     abstract public Flux<T> flux();
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#stream(reactor.core.publisher.Flux)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #stream(reactor.core.publisher.Flux)
      */
     @Override
     abstract public <X> FluentCollectionX<X> stream(Flux<X> stream);
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusLazy(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusLazy(java.lang.Object)
      */
     @Override
     public LazyFluentCollectionX<T> plusLazy(final T e) {
@@ -126,8 +139,12 @@ public LazyFluentCollectionX<T> plusLazy(final T e) {
 
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plus(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plus(java.lang.Object)
      */
     @Override
     public FluentCollectionX<T> plus(final T e) {
@@ -135,8 +152,12 @@ public FluentCollectionX<T> plus(final T e) {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusAll(java.util.Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusAll(java.util.Collection)
      */
     @Override
     public FluentCollectionX<T> plusAll(final Collection<? extends T> list) {
@@ -144,8 +165,12 @@ public FluentCollectionX<T> plusAll(final Collection<? extends T> list) {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#minus(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #minus(java.lang.Object)
      */
     @Override
     public FluentCollectionX<T> minus(final Object e) {
@@ -153,8 +178,12 @@ public FluentCollectionX<T> minus(final Object e) {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#minusAll(java.util.Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #minusAll(java.util.Collection)
      */
     @Override
     public FluentCollectionX<T> minusAll(final Collection<?> list) {
@@ -197,19 +226,25 @@ public LazyFluentCollectionX<T> minusLazy(final Object e) {
      */
     @Override
     public LazyFluentCollectionX<T> minusAllLazy(final Collection<?> list) {
-        return(LazyFluentCollectionX<T>) this.removeAll((Iterable) list);
+        return (LazyFluentCollectionX<T>) this.removeAll((Iterable) list);
 
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#combine(java.util
+     * .function.BiPredicate, java.util.function.BinaryOperator)
      */
     @Override
     public FluentCollectionX<T> combine(final BiPredicate<? super T, ? super T> predicate, final BinaryOperator<T> op) {
         return stream(Fluxes.combine(flux(), predicate, op));
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#reverse()
      */
     @Override
@@ -217,31 +252,45 @@ public FluentCollectionX<T> reverse() {
         return stream(Fluxes.reverse(flux()));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#filter(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#filter(java.util.
+     * function.Predicate)
      */
     @Override
     public FluentCollectionX<T> filter(final Predicate<? super T> pred) {
         return stream(flux().filter(pred));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#map(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#map(java.util.
+     * function.Function)
      */
     @Override
     public <R> CollectionX<R> map(final Function<? super T, ? extends R> mapper) {
         return stream(flux().map(mapper));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#flatMap(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#flatMap(java.util
+     * .function.Function)
      */
     @Override
     public <R> CollectionX<R> flatMap(final Function<? super T, ? extends Iterable<? extends R>> mapper) {
         return stream(flux().flatMap(mapper.andThen(ReactiveSeq::fromIterable)));
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#limit(long)
      */
     @Override
@@ -249,7 +298,9 @@ public FluentCollectionX<T> limit(final long num) {
         return stream(flux().take(num));
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#skip(long)
      */
     @Override
@@ -257,48 +308,70 @@ public FluentCollectionX<T> skip(final long num) {
         return stream(flux().skip(num));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#takeRight(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#takeRight(int)
      */
     @Override
     public FluentCollectionX<T> takeRight(final int num) {
         return stream(flux().takeLast(num));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#dropRight(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#dropRight(int)
      */
     @Override
     public FluentCollectionX<T> dropRight(final int num) {
         return stream(flux().skipLast(num));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#takeWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#takeWhile(java.
+     * util.function.Predicate)
      */
     @Override
     public FluentCollectionX<T> takeWhile(final Predicate<? super T> p) {
         return stream(flux().takeWhile(p));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#dropWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#dropWhile(java.
+     * util.function.Predicate)
      */
     @Override
     public FluentCollectionX<T> dropWhile(final Predicate<? super T> p) {
         return stream(flux().skipWhile(p));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#takeUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#takeUntil(java.
+     * util.function.Predicate)
      */
     @Override
     public FluentCollectionX<T> takeUntil(final Predicate<? super T> p) {
         return stream(Fluxes.takeUntil(flux(), p));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#dropUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#dropUntil(java.
+     * util.function.Predicate)
      */
     @Override
     public FluentCollectionX<T> dropUntil(final Predicate<? super T> p) {
@@ -307,7 +380,10 @@ public FluentCollectionX<T> dropUntil(final Predicate<? super T> p) {
 
     /*
      * (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.CollectionX#trampoline(java.util.function.Function)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.CollectionX#trampoline(java.
+     * util.function.Function)
      */
     @Override
     public <R> FluentCollectionX<R> trampoline(final Function<? super T, ? extends Trampoline<? extends R>> mapper) {
@@ -396,7 +472,7 @@ public <U, R> FluentCollectionX<R> zip(final Iterable<? extends U> other,
     @Override
     public FluentCollectionX<ListX<T>> sliding(final int windowSize) {
         return stream(Fluxes.sliding(flux(), windowSize, 1)
-                               .map(ListX::fromPublisher));
+                            .map(ListX::fromPublisher));
     }
 
     /*
@@ -408,7 +484,7 @@ public FluentCollectionX<ListX<T>> sliding(final int windowSize) {
     @Override
     public FluentCollectionX<ListX<T>> sliding(final int windowSize, final int increment) {
         return stream(Fluxes.sliding(flux(), windowSize, increment)
-                               .map(ListX::fromPublisher));
+                            .map(ListX::fromPublisher));
     }
 
     /*
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollection.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollection.java
index 3182b547..9a1c2086 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollection.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollection.java
@@ -12,13 +12,13 @@
  * @param <T>  the type of elements held in the wrapped collection
  * @param <C> The wrapped Collection type
  */
-public interface LazyFluentCollection<T,C extends Collection<T>> {
-    
+public interface LazyFluentCollection<T, C extends Collection<T>> {
+
     /**
      * @return Wrapped Collection
      */
     C get();
-    
+
     /**
      * @return Collection data inside a stream - a Reactor Flux
      */
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollectionX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollectionX.java
index 54fdee76..16b3357d 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollectionX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/base/LazyFluentCollectionX.java
@@ -16,7 +16,7 @@
  * @param <T> the type of elements held in this collection
  */
 public interface LazyFluentCollectionX<T> extends FluentCollectionX<T> {
-    
+
     /**
      * Create a LazyFluentCollection from a Flux. 
      * The created LazyFluentCollection will be of the same type as the object this method is called on.
@@ -36,13 +36,13 @@ public interface LazyFluentCollectionX<T> extends FluentCollectionX<T> {
      * The same collection / reduction method will be used in the newly created Object. I.e. Calling  stream(Flux) on 
      * a collection which as an Immutable Collector  will result in an Immutable Collection.
      * 
-
+    
      * 
      * @param stream Flux to create new collection from
      * @return New collection from Flux
      */
     <X> FluentCollectionX<X> stream(Flux<X> stream);
-    
+
     /**
      * Lazily add an element to this Collection.
      * The Collection will not be materialized (unlike via @see {@link LazyFluentCollectionX#plus(Object)}
@@ -59,11 +59,11 @@ public interface LazyFluentCollectionX<T> extends FluentCollectionX<T> {
      * @param e Element to add
      * @return LazyFluentCollectionX with element added
      */
-    default LazyFluentCollectionX<T> plusLazy(T e){
+    default LazyFluentCollectionX<T> plusLazy(T e) {
         add(e);
         return this;
     }
-    
+
     /**
      * Lazily add all the elements in the supplied Collection to this Collection.
      * The Collection will not be materialized (unlike via @see {@link LazyFluentCollectionX#plusAll(Object)}
@@ -79,11 +79,11 @@ default LazyFluentCollectionX<T> plusLazy(T e){
      * @param col Collection to add
      * @return LazyFluentCollectionX with Collection added
      */
-    default LazyFluentCollectionX<T> plusAllLazy(Collection<? extends T> col){
+    default LazyFluentCollectionX<T> plusAllLazy(Collection<? extends T> col) {
         addAll(col);
         return this;
     }
-    
+
     /**
      * Lazily remove an element from this Collection.
      * The Collection will not be materialized (unlike via @see {@link LazyFluentCollectionX#minus(Object)}
@@ -111,11 +111,11 @@ default LazyFluentCollectionX<T> plusAllLazy(Collection<? extends T> col){
      * @param e Element to remove
      * @return LazyFluentCollectionX with element removed
      */
-    default LazyFluentCollectionX<T> minusLazy(Object e){
+    default LazyFluentCollectionX<T> minusLazy(Object e) {
         remove(e);
         return this;
     }
-    
+
     /**
      * Lazily remove the elements in the supplied Collection from this Collection.
      * The Collection will not be materialized (unlike via @see {@link LazyFluentCollectionX#minusAll(Collection)}
@@ -142,46 +142,70 @@ default LazyFluentCollectionX<T> minusLazy(Object e){
      * @param list of elements to remove
      * @return  LazyFluentCollectionX with elements removed
      */
-    default LazyFluentCollectionX<T> minusAllLazy(Collection<?> list){
+    default LazyFluentCollectionX<T> minusAllLazy(Collection<?> list) {
         removeAll(list);
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.FluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.FluentCollectionX#plusInOrder
+     * (java.lang.Object)
      */
     @Override
-    default FluentCollectionX<T> plusInOrder(T e){
+    default FluentCollectionX<T> plusInOrder(T e) {
         return plus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.FluentCollectionX#plus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.FluentCollectionX#plus(java.
+     * lang.Object)
      */
     @Override
     public FluentCollectionX<T> plus(T e);
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.FluentCollectionX#plusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.FluentCollectionX#plusAll(
+     * java.util.Collection)
      */
     @Override
-    public FluentCollectionX<T> plusAll(Collection<? extends T> list) ;
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.FluentCollectionX#minus(java.lang.Object)
+    public FluentCollectionX<T> plusAll(Collection<? extends T> list);
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.FluentCollectionX#minus(java.
+     * lang.Object)
      */
     @Override
     public FluentCollectionX<T> minus(Object e);
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.FluentCollectionX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.FluentCollectionX#minusAll(
+     * java.util.Collection)
      */
     @Override
     public FluentCollectionX<T> minusAll(Collection<?> list);
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.FluentCollectionX#unit(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.FluentCollectionX#unit(java.
+     * util.Collection)
      */
     @Override
     public <R> FluentCollectionX<R> unit(Collection<R> col);
 }
-
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPBagX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPBagX.java
index 921b0b9f..e017fdd6 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPBagX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPBagX.java
@@ -44,6 +44,7 @@
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended Bag type
  * This makes use of PBag (@see org.pcollections.PBag) from PCollectons.
@@ -72,24 +73,23 @@
  *
  * @param <T> the type of elements held in this collection
  */
-@AllArgsConstructor(access=AccessLevel.PRIVATE)
-public class LazyPBagX<T> extends AbstractFluentCollectionX<T> implements PBagX<T> {
-    private final  LazyFluentCollection<T,PBag<T>> lazy;
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class LazyPBagX<T> extends AbstractFluentCollectionX<T>implements PBagX<T> {
+    private final LazyFluentCollection<T, PBag<T>> lazy;
     @Getter
     private final Reducer<PBag<T>> collector;
-   
 
-  
-    
     /**
      * Create a LazyPStackX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyPStackX
      */
-    public static <T> LazyPBagX<T> fromStreamS(Stream<T> stream){
-        return new LazyPBagX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyPBagX<T> fromStreamS(Stream<T> stream) {
+        return new LazyPBagX<T>(
+                                Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyPStackX that contains the Integers between start and end
      * 
@@ -145,7 +145,7 @@ public static <U, T> LazyPBagX<T> unfold(U seed, Function<? super U, Optional<Tu
     public static <T> LazyPBagX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -158,10 +158,9 @@ public static <T> LazyPBagX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyPBagX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyPStackX
      */
@@ -169,14 +168,13 @@ public static <T> LazyPBagX<T> iterate(long limit, final T seed, final UnaryOper
         return Collectors.toCollection(() -> LazyPBagX.of());
     }
 
-   
-
     /**
      * @return An empty LazyPStackX
      */
     public static <T> LazyPBagX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -197,8 +195,9 @@ public static <T> LazyPBagX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyPBagX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -252,42 +251,54 @@ public static <T> LazyPBagX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyPBagX<T> fromIterable(Reducer<PBag<T>> collector, Iterable<T> it) {
         if (it instanceof LazyPBagX)
             return (LazyPBagX<T>) it;
-       
+
         if (it instanceof PBag)
             return new LazyPBagX<T>(
                                     (PBag<T>) it, collector);
-        
+
         return new LazyPBagX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                Flux.fromIterable(it), collector);
     }
-    private LazyPBagX(PBag<T> list,Reducer<PBag<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PBag<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPBagX(PBag<T> list, Reducer<PBag<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PBag<T>>(
+                                                             list, null, collector);
+        this.collector = collector;
     }
-    private LazyPBagX(boolean efficientOps,PBag<T> list,Reducer<PBag<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PBag<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPBagX(boolean efficientOps, PBag<T> list, Reducer<PBag<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PBag<T>>(
+                                                             list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyPBagX(PBag<T> list){
+
+    private LazyPBagX(PBag<T> list) {
         this.collector = Reducers.toPBag();
-        this.lazy = new PersistentLazyCollection<T,PBag<T>>(list,null,Reducers.toPBag());
+        this.lazy = new PersistentLazyCollection<T, PBag<T>>(
+                                                             list, null, Reducers.toPBag());
     }
-    private LazyPBagX(Flux<T> stream,Reducer<PBag<T>> collector){
+
+    private LazyPBagX(Flux<T> stream, Reducer<PBag<T>> collector) {
         this.collector = collector;
-        this.lazy = new PersistentLazyCollection<>(null,stream,Reducers.toPBag());
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, Reducers.toPBag());
     }
-    private LazyPBagX(Flux<T> stream){
+
+    private LazyPBagX(Flux<T> stream) {
         this.collector = Reducers.toPBag();
-        this.lazy = new PersistentLazyCollection<>(null,stream,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, collector);
     }
-    private LazyPBagX(){
+
+    private LazyPBagX() {
         this.collector = Reducers.toPBag();
-        this.lazy = new PersistentLazyCollection<>((PBag)this.collector.zero(),null,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   (PBag) this.collector.zero(), null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -295,7 +306,9 @@ public void forEach(Consumer<? super T> action) {
         getBag().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -303,7 +316,9 @@ public Iterator<T> iterator() {
         return getBag().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -311,7 +326,9 @@ public int size() {
         return getBag().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -319,7 +336,9 @@ public boolean contains(Object e) {
         return getBag().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -327,9 +346,9 @@ public boolean equals(Object o) {
         return getBag().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -337,7 +356,9 @@ public boolean isEmpty() {
         return getBag().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -345,7 +366,9 @@ public int hashCode() {
         return getBag().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -353,7 +376,9 @@ public Object[] toArray() {
         return getBag().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -361,7 +386,9 @@ public boolean removeAll(Collection<?> c) {
         return getBag().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -369,7 +396,9 @@ public <T> T[] toArray(T[] a) {
         return getBag().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -377,7 +406,9 @@ public boolean add(T e) {
         return getBag().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -385,7 +416,9 @@ public boolean remove(Object o) {
         return getBag().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -393,7 +426,9 @@ public boolean containsAll(Collection<?> c) {
         return getBag().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -401,7 +436,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getBag().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -409,7 +446,9 @@ public boolean retainAll(Collection<?> c) {
         return getBag().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -417,8 +456,9 @@ public void clear() {
         getBag().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -426,7 +466,9 @@ public String toString() {
         return getBag().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -434,847 +476,1103 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getBag().removeIf(filter);
     }
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getBag().parallelStream();
     }
-    
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getBag().spliterator();
     }
-   
+
     /**
      * @return PQueue
      */
     private PBag<T> getBag() {
         return lazy.get();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyPBagX<X> stream(Flux<X> stream){
-        return new LazyPBagX<X>(stream);
+    public <X> LazyPBagX<X> stream(Flux<X> stream) {
+        return new LazyPBagX<X>(
+                                stream);
     }
-   
-    
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flux()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flux()
      */
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combine(java.util.function.BiPredicate,
+     * java.util.function.BinaryOperator)
      */
     @Override
     public LazyPBagX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyPBagX<T>)super.combine(predicate, op);
+
+        return (LazyPBagX<T>) super.combine(predicate, op);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#reverse()
      */
     @Override
     public LazyPBagX<T> reverse() {
-       
-        return(LazyPBagX<T>)super.reverse();
+
+        return (LazyPBagX<T>) super.reverse();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filter(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyPBagX<T>)super.filter(pred);
+
+        return (LazyPBagX<T>) super.filter(pred);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#map(java.util.function.Function)
      */
     @Override
     public <R> LazyPBagX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyPBagX<R>)super.map(mapper);
+
+        return (LazyPBagX<R>) super.map(mapper);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flatMap(java.util.function.Function)
      */
     @Override
     public <R> LazyPBagX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyPBagX<R>)super.flatMap(mapper);
+        return (LazyPBagX<R>) super.flatMap(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limit(long)
      */
     @Override
     public LazyPBagX<T> limit(long num) {
-       return (LazyPBagX<T>)super.limit(num);
+        return (LazyPBagX<T>) super.limit(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skip(long)
      */
     @Override
     public LazyPBagX<T> skip(long num) {
-       return (LazyPBagX<T>)super.skip(num);
+        return (LazyPBagX<T>) super.skip(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeRight(int)
      */
     @Override
     public LazyPBagX<T> takeRight(int num) {
-       return (LazyPBagX<T>)super.takeRight(num);
+        return (LazyPBagX<T>) super.takeRight(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropRight(int)
      */
     @Override
     public LazyPBagX<T> dropRight(int num) {
-       return (LazyPBagX<T>)super.dropRight(num);
+        return (LazyPBagX<T>) super.dropRight(num);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyPBagX<T>)super.takeWhile(p);
+        return (LazyPBagX<T>) super.takeWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyPBagX<T>)super.dropWhile(p);
+        return (LazyPBagX<T>) super.dropWhile(p);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyPBagX<T>)super.takeUntil(p);
+        return (LazyPBagX<T>) super.takeUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyPBagX<T>)super.dropUntil(p);
+        return (LazyPBagX<T>) super.dropUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#trampoline(java.util.function.Function)
      */
     @Override
     public <R> LazyPBagX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyPBagX<R>)super.trampoline(mapper);
+        return (LazyPBagX<R>) super.trampoline(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#slice(long, long)
      */
     @Override
     public LazyPBagX<T> slice(long from, long to) {
-       return (LazyPBagX<T>)super.slice(from, to);
+        return (LazyPBagX<T>) super.slice(from, to);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int)
      */
     @Override
     public LazyPBagX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyPBagX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyPBagX<ListX<T>>) super.grouped(groupSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function,
+     * java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyPBagX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyPBagX)super.grouped(classifier, downstream);
+
+        return (LazyPBagX) super.grouped(classifier, downstream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function)
      */
     @Override
     public <K> LazyPBagX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyPBagX)super.grouped(classifier);
+
+        return (LazyPBagX) super.grouped(classifier);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable)
      */
     @Override
     public <U> LazyPBagX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyPBagX)super.zip(other);
+
+        return (LazyPBagX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazyPBagX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyPBagX<R>)super.zip(other, zipper);
+
+        return (LazyPBagX<R>) super.zip(other, zipper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int)
      */
     @Override
     public LazyPBagX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyPBagX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyPBagX<ListX<T>>) super.sliding(windowSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int, int)
      */
     @Override
     public LazyPBagX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyPBagX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyPBagX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPBagX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyPBagX<T>)super.scanLeft(monoid);
+
+        return (LazyPBagX<T>) super.scanLeft(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPBagX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyPBagX<U>) super.scanLeft(seed, function);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPBagX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyPBagX<T>)super.scanRight(monoid);
+
+        return (LazyPBagX<T>) super.scanRight(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPBagX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyPBagX<U>)super.scanRight(identity, combiner);
+
+        return (LazyPBagX<U>) super.scanRight(identity, combiner);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyPBagX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyPBagX<T>)super.sorted(function);
+
+        return (LazyPBagX<T>) super.sorted(function);
     }
-    
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusLazy(java.lang.Object)
      */
     @Override
     public LazyPBagX<T> plusLazy(T e) {
-       
-        return (LazyPBagX<T>)super.plusLazy(e);
+
+        return (LazyPBagX<T>) super.plusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPBagX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyPBagX<T>)super.plusAllLazy(list);
+
+        return (LazyPBagX<T>) super.plusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusLazy(java.lang.Object)
      */
     @Override
     public LazyPBagX<T> minusLazy(Object e) {
-       
-        return (LazyPBagX<T>)super.minusLazy(e);
+
+        return (LazyPBagX<T>) super.minusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPBagX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyPBagX<T>)super.minusAllLazy(list);
+
+        return (LazyPBagX<T>) super.minusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(int)
      */
     @Override
     public LazyPBagX<T> cycle(int times) {
-        return (LazyPBagX<T>)super.cycle(times);
+        return (LazyPBagX<T>) super.cycle(times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
      */
     @Override
     public LazyPBagX<T> cycle(Monoid<T> m, int times) {
-        return (LazyPBagX<T>)super.cycle(m,times);
+        return (LazyPBagX<T>) super.cycle(m, times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> cycleWhile(Predicate<? super T> predicate) {
-        return (LazyPBagX<T>)super.cycleWhile(predicate);
+        return (LazyPBagX<T>) super.cycleWhile(predicate);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> cycleUntil(Predicate<? super T> predicate) {
-        return (LazyPBagX<T>)super.cycleUntil(predicate);
+        return (LazyPBagX<T>) super.cycleUntil(predicate);
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
      */
     @Override
     public <U> LazyPBagX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyPBagX)super.zip(other);
+
+        return (LazyPBagX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip3(java.util.stream.Stream,
+     * java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyPBagX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyPBagX)super.zip3(second, third);
+
+        return (LazyPBagX) super.zip3(second, third);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip4(java.util.stream.Stream,
+     * java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazyPBagX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazyPBagX)super.zip4(second, third, fourth);
+
+        return (LazyPBagX) super.zip4(second, third, fourth);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zipWithIndex()
      */
     @Override
     public LazyPBagX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyPBagX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyPBagX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#distinct()
      */
     @Override
     public LazyPBagX<T> distinct() {
-       
-        return (LazyPBagX<T>)super.distinct();
+
+        return (LazyPBagX<T>) super.distinct();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted()
      */
     @Override
     public LazyPBagX<T> sorted() {
-       
-        return (LazyPBagX<T>)super.sorted();
+
+        return (LazyPBagX<T>) super.sorted();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.Comparator)
      */
     @Override
     public LazyPBagX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyPBagX<T>)super.sorted(c);
+
+        return (LazyPBagX<T>) super.sorted(c);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyPBagX<T>)super.skipWhile(p);
+
+        return (LazyPBagX<T>) super.skipWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyPBagX<T>)super.skipUntil(p);
+
+        return (LazyPBagX<T>) super.skipUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyPBagX<T>)super.limitWhile(p);
+
+        return (LazyPBagX<T>) super.limitWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyPBagX<T>)super.limitUntil(p);
+
+        return (LazyPBagX<T>) super.limitUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#intersperse(java.lang.Object)
      */
     @Override
     public LazyPBagX<T> intersperse(T value) {
-       
-        return (LazyPBagX<T>)super.intersperse(value);
+
+        return (LazyPBagX<T>) super.intersperse(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle()
      */
     @Override
     public LazyPBagX<T> shuffle() {
-       
-        return (LazyPBagX<T>)super.shuffle();
+
+        return (LazyPBagX<T>) super.shuffle();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipLast(int)
      */
     @Override
     public LazyPBagX<T> skipLast(int num) {
-       
-        return (LazyPBagX<T>)super.skipLast(num);
+
+        return (LazyPBagX<T>) super.skipLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitLast(int)
      */
     @Override
     public LazyPBagX<T> limitLast(int num) {
-       
-        return (LazyPBagX<T>)super.limitLast(num);
+
+        return (LazyPBagX<T>) super.limitLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmpty(java.lang.Object)
      */
     @Override
     public LazyPBagX<T> onEmpty(T value) {
-       
-        return (LazyPBagX<T>)super.onEmpty(value);
+
+        return (LazyPBagX<T>) super.onEmpty(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
      */
     @Override
     public LazyPBagX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyPBagX<T>)super.onEmptyGet(supplier);
+
+        return (LazyPBagX<T>) super.onEmptyGet(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyPBagX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyPBagX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyPBagX<T>) super.onEmptyThrow(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle(java.util.Random)
      */
     @Override
     public LazyPBagX<T> shuffle(Random random) {
-       
-        return (LazyPBagX<T>)super.shuffle(random);
+
+        return (LazyPBagX<T>) super.shuffle(random);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#ofType(java.lang.Class)
      */
     @Override
     public <U> LazyPBagX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyPBagX<U>)super.ofType(type);
+
+        return (LazyPBagX<U>) super.ofType(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyPBagX<T>)super.filterNot(fn);
+
+        return (LazyPBagX<T>) super.filterNot(fn);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#notNull()
      */
     @Override
     public LazyPBagX<T> notNull() {
-       
-        return (LazyPBagX<T>)super.notNull();
+
+        return (LazyPBagX<T>) super.notNull();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
      */
     @Override
     public LazyPBagX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyPBagX<T>)(super.removeAll(stream));
+
+        return (LazyPBagX<T>) (super.removeAll(stream));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPBagX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyPBagX<T>)super.removeAll(stream);
+
+        return (LazyPBagX<T>) super.removeAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Iterable)
      */
     @Override
     public LazyPBagX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyPBagX<T>)super.removeAll(it);
+
+        return (LazyPBagX<T>) super.removeAll(it);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Object[])
      */
     @Override
     public LazyPBagX<T> removeAll(T... values) {
-       
-        return (LazyPBagX<T>)super.removeAll(values);
+
+        return (LazyPBagX<T>) super.removeAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Iterable)
      */
     @Override
     public LazyPBagX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyPBagX<T>)super.retainAll(it);
+
+        return (LazyPBagX<T>) super.retainAll(it);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
      */
     @Override
     public LazyPBagX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyPBagX<T>)super.retainAll(stream);
+
+        return (LazyPBagX<T>) super.retainAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPBagX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyPBagX<T>)super.retainAll(stream);
+
+        return (LazyPBagX<T>) super.retainAll(stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Object[])
      */
     @Override
     public LazyPBagX<T> retainAll(T... values) {
-       
-        return (LazyPBagX<T>)super.retainAll(values);
+
+        return (LazyPBagX<T>) super.retainAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cast(java.lang.Class)
      */
     @Override
     public <U> LazyPBagX<U> cast(Class<? extends U> type) {
-       
-        return (LazyPBagX<U>)super.cast(type);
+
+        return (LazyPBagX<U>) super.cast(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
     public <R> LazyPBagX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyPBagX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyPBagX<R>) super.patternMatch(case1, otherwise);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#permutations()
      */
     @Override
     public LazyPBagX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyPBagX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyPBagX<ReactiveSeq<T>>) super.permutations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations(int)
      */
     @Override
     public LazyPBagX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyPBagX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyPBagX<ReactiveSeq<T>>) super.combinations(size);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations()
      */
     @Override
     public LazyPBagX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyPBagX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyPBagX<ReactiveSeq<T>>) super.combinations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPBagX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyPBagX<C>)super.grouped(size, supplier);
+
+        return (LazyPBagX<C>) super.grouped(size, supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPBagX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyPBagX<ListX<T>>) super.groupedUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPBagX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPBagX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyPBagX<ListX<T>>) super.groupedWhile(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPBagX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPBagX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyPBagX<C>) super.groupedWhile(predicate, factory);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPBagX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPBagX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyPBagX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** PStackX methods **/
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int, java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int,
+     * java.lang.Object)
      */
-    public LazyPBagX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyPBagX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    
- 
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyPBagX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyPBagX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyPBagX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyPBagX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyPBagX)super.peek(c);
+
+        return (LazyPBagX) super.peek(c);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPBagX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyPBagX<R>)super.zip(other, zipper);
+    public <U, R> LazyPBagX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPBagX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPBagX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyPBagX<R>)super.zip(other, zipper);
+    public <U, R> LazyPBagX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPBagX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyPBagX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyPBagX)super.zip(other);
+
+        return (LazyPBagX) super.zip(other);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyPBagX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyPBagX<R>)super.zip(fn, publisher);
+
+        return (LazyPBagX<R>) super.zip(fn, publisher);
     }
- 
-   
-  
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyPBagX<T> onEmptySwitch(Supplier<? extends PBag<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
-       
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
+
     }
-    
 
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(
+     * Collection)
      */
     @Override
     public <R> LazyPBagX<R> unit(Collection<R> col) {
-       
+
         return fromIterable(col);
     }
-    
+
     @Override
     public <R> LazyPBagX<R> unit(R value) {
         return singleton(value);
     }
 
     @Override
-    public<R> LazyPBagX<R> unitIterator(Iterator<R> it) {
+    public <R> LazyPBagX<R> unitIterator(Iterator<R> it) {
         return fromIterable(() -> it);
     }
 
     @Override
     public <R> LazyPBagX<R> emptyUnit() {
-       
+
         return LazyPBagX.<R> empty();
     }
 
@@ -1285,15 +1583,21 @@ public LazyPBagX<T> toPVector() {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyPBagX<T> plusInOrder(T e) {
         return plus(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#stream()
      */
     @Override
@@ -1301,56 +1605,75 @@ public ReactiveSeq<T> stream() {
 
         return ReactiveSeq.fromIterable(this);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <X> LazyPBagX<X> from(Collection<X> col) {
         return fromIterable(col);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
      */
     @Override
     public <T> Reducer<PBag<T>> monoid() {
-       
+
         return Reducers.toPBag();
 
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plus(java.lang.Object)
      */
     @Override
     public LazyPBagX<T> plus(T e) {
-        return new LazyPBagX<T>(getBag().plus(e),this.collector);
+        return new LazyPBagX<T>(
+                                getBag().plus(e), this.collector);
     }
-    
-  
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plusAll(java.util.Collection)
      */
     @Override
-    public  LazyPBagX<T> plusAll(Collection<? extends T> list) {
-        return new LazyPBagX<T>(getBag().plusAll(list),this.collector);
+    public LazyPBagX<T> plusAll(Collection<? extends T> list) {
+        return new LazyPBagX<T>(
+                                getBag().plusAll(list), this.collector);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minus(java.lang.Object)
      */
     @Override
-    public  LazyPBagX<T> minus(Object e) {
+    public LazyPBagX<T> minus(Object e) {
         PCollection<T> res = getBag().minus(e);
-        return LazyPBagX.fromIterable(this.collector,res);
-        
+        return LazyPBagX.fromIterable(this.collector, res);
+
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAll(java.util.Collection)
      */
     public LazyPBagX<T> minusAll(Collection<?> list) {
         PCollection<T> res = getBag().minusAll(list);
-        return LazyPBagX.fromIterable(this.collector,res);
+        return LazyPBagX.fromIterable(this.collector, res);
     }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPOrderedSetX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPOrderedSetX.java
index 4e977290..4ef461cd 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPOrderedSetX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPOrderedSetX.java
@@ -43,6 +43,7 @@
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended OrderedSet type {@see java.util.Set}
  * This makes use of POrderedSet (@see org.pcollections.POrderedSet) from PCollectons.
@@ -75,24 +76,23 @@
  *
  * @param <T> the type of elements held in this collection
  */
-@AllArgsConstructor(access=AccessLevel.PRIVATE)
-public class LazyPOrderedSetX<T> extends AbstractFluentCollectionX<T> implements POrderedSetX<T> {
-    private final  LazyFluentCollection<T,POrderedSet<T>> lazy;
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class LazyPOrderedSetX<T> extends AbstractFluentCollectionX<T>implements POrderedSetX<T> {
+    private final LazyFluentCollection<T, POrderedSet<T>> lazy;
     @Getter
     private final Reducer<POrderedSet<T>> collector;
-   
 
-  
-    
     /**
      * Create a LazyPStackX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyPStackX
      */
-    public static <T> LazyPOrderedSetX<T> fromStreamS(Stream<T> stream){
-        return new LazyPOrderedSetX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyPOrderedSetX<T> fromStreamS(Stream<T> stream) {
+        return new LazyPOrderedSetX<T>(
+                                       Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyPStackX that contains the Integers between start and end
      * 
@@ -148,7 +148,7 @@ public static <U, T> LazyPOrderedSetX<T> unfold(U seed, Function<? super U, Opti
     public static <T> LazyPOrderedSetX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -161,10 +161,9 @@ public static <T> LazyPOrderedSetX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyPOrderedSetX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyPStackX
      */
@@ -172,14 +171,13 @@ public static <T> LazyPOrderedSetX<T> iterate(long limit, final T seed, final Un
         return Collectors.toCollection(() -> LazyPOrderedSetX.of());
     }
 
-   
-
     /**
      * @return An empty LazyPStackX
      */
     public static <T> LazyPOrderedSetX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -200,8 +198,9 @@ public static <T> LazyPOrderedSetX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyPOrderedSetX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -255,42 +254,54 @@ public static <T> LazyPOrderedSetX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyPOrderedSetX<T> fromIterable(Reducer<POrderedSet<T>> collector, Iterable<T> it) {
         if (it instanceof LazyPOrderedSetX)
             return (LazyPOrderedSetX<T>) it;
-       
+
         if (it instanceof POrderedSet)
             return new LazyPOrderedSetX<T>(
-                                    (POrderedSet<T>) it, collector);
-        
+                                           (POrderedSet<T>) it, collector);
+
         return new LazyPOrderedSetX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                       Flux.fromIterable(it), collector);
     }
-    private LazyPOrderedSetX(POrderedSet<T> list,Reducer<POrderedSet<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,POrderedSet<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPOrderedSetX(POrderedSet<T> list, Reducer<POrderedSet<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, POrderedSet<T>>(
+                                                                    list, null, collector);
+        this.collector = collector;
     }
-    private LazyPOrderedSetX(boolean efficientOps,POrderedSet<T> list,Reducer<POrderedSet<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,POrderedSet<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPOrderedSetX(boolean efficientOps, POrderedSet<T> list, Reducer<POrderedSet<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, POrderedSet<T>>(
+                                                                    list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyPOrderedSetX(POrderedSet<T> list){
+
+    private LazyPOrderedSetX(POrderedSet<T> list) {
         this.collector = Reducers.toPOrderedSet();
-        this.lazy = new PersistentLazyCollection<T,POrderedSet<T>>(list,null,Reducers.toPOrderedSet());
+        this.lazy = new PersistentLazyCollection<T, POrderedSet<T>>(
+                                                                    list, null, Reducers.toPOrderedSet());
     }
-    private LazyPOrderedSetX(Flux<T> stream,Reducer<POrderedSet<T>> collector){
+
+    private LazyPOrderedSetX(Flux<T> stream, Reducer<POrderedSet<T>> collector) {
         this.collector = collector;
-        this.lazy = new PersistentLazyCollection<>(null,stream,Reducers.toPOrderedSet());
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, Reducers.toPOrderedSet());
     }
-    private LazyPOrderedSetX(Flux<T> stream){
+
+    private LazyPOrderedSetX(Flux<T> stream) {
         this.collector = Reducers.toPOrderedSet();
-        this.lazy = new PersistentLazyCollection<>(null,stream,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, collector);
     }
-    private LazyPOrderedSetX(){
+
+    private LazyPOrderedSetX() {
         this.collector = Reducers.toPOrderedSet();
-        this.lazy = new PersistentLazyCollection<>((POrderedSet)this.collector.zero(),null,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   (POrderedSet) this.collector.zero(), null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -298,7 +309,9 @@ public void forEach(Consumer<? super T> action) {
         getSet().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -306,7 +319,9 @@ public Iterator<T> iterator() {
         return getSet().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -314,7 +329,9 @@ public int size() {
         return getSet().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -322,7 +339,9 @@ public boolean contains(Object e) {
         return getSet().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -330,9 +349,9 @@ public boolean equals(Object o) {
         return getSet().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -340,7 +359,9 @@ public boolean isEmpty() {
         return getSet().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -348,7 +369,9 @@ public int hashCode() {
         return getSet().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -356,7 +379,9 @@ public Object[] toArray() {
         return getSet().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -364,7 +389,9 @@ public boolean removeAll(Collection<?> c) {
         return getSet().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -372,7 +399,9 @@ public <T> T[] toArray(T[] a) {
         return getSet().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -380,7 +409,9 @@ public boolean add(T e) {
         return getSet().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -388,7 +419,9 @@ public boolean remove(Object o) {
         return getSet().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -396,7 +429,9 @@ public boolean containsAll(Collection<?> c) {
         return getSet().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -404,7 +439,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getSet().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -412,7 +449,9 @@ public boolean retainAll(Collection<?> c) {
         return getSet().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -420,8 +459,9 @@ public void clear() {
         getSet().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -429,7 +469,9 @@ public String toString() {
         return getSet().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -437,847 +479,1110 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getSet().removeIf(filter);
     }
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getSet().parallelStream();
     }
-    
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getSet().spliterator();
     }
-   
+
     /**
      * @return POrderedSet
      */
     private POrderedSet<T> getSet() {
         return lazy.get();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyPOrderedSetX<X> stream(Flux<X> stream){
-        return new LazyPOrderedSetX<X>(stream);
+    public <X> LazyPOrderedSetX<X> stream(Flux<X> stream) {
+        return new LazyPOrderedSetX<X>(
+                                       stream);
     }
-   
-    
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flux()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flux()
      */
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combine(java.util.function.BiPredicate,
+     * java.util.function.BinaryOperator)
      */
     @Override
     public LazyPOrderedSetX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyPOrderedSetX<T>)super.combine(predicate, op);
+
+        return (LazyPOrderedSetX<T>) super.combine(predicate, op);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#reverse()
      */
     @Override
     public LazyPOrderedSetX<T> reverse() {
-       
-        return(LazyPOrderedSetX<T>)super.reverse();
+
+        return (LazyPOrderedSetX<T>) super.reverse();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filter(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyPOrderedSetX<T>)super.filter(pred);
+
+        return (LazyPOrderedSetX<T>) super.filter(pred);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#map(java.util.function.Function)
      */
     @Override
     public <R> LazyPOrderedSetX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyPOrderedSetX<R>)super.map(mapper);
+
+        return (LazyPOrderedSetX<R>) super.map(mapper);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flatMap(java.util.function.Function)
      */
     @Override
     public <R> LazyPOrderedSetX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyPOrderedSetX<R>)super.flatMap(mapper);
+        return (LazyPOrderedSetX<R>) super.flatMap(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limit(long)
      */
     @Override
     public LazyPOrderedSetX<T> limit(long num) {
-       return (LazyPOrderedSetX<T>)super.limit(num);
+        return (LazyPOrderedSetX<T>) super.limit(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skip(long)
      */
     @Override
     public LazyPOrderedSetX<T> skip(long num) {
-       return (LazyPOrderedSetX<T>)super.skip(num);
+        return (LazyPOrderedSetX<T>) super.skip(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeRight(int)
      */
     @Override
     public LazyPOrderedSetX<T> takeRight(int num) {
-       return (LazyPOrderedSetX<T>)super.takeRight(num);
+        return (LazyPOrderedSetX<T>) super.takeRight(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropRight(int)
      */
     @Override
     public LazyPOrderedSetX<T> dropRight(int num) {
-       return (LazyPOrderedSetX<T>)super.dropRight(num);
+        return (LazyPOrderedSetX<T>) super.dropRight(num);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyPOrderedSetX<T>)super.takeWhile(p);
+        return (LazyPOrderedSetX<T>) super.takeWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyPOrderedSetX<T>)super.dropWhile(p);
+        return (LazyPOrderedSetX<T>) super.dropWhile(p);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyPOrderedSetX<T>)super.takeUntil(p);
+        return (LazyPOrderedSetX<T>) super.takeUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyPOrderedSetX<T>)super.dropUntil(p);
+        return (LazyPOrderedSetX<T>) super.dropUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#trampoline(java.util.function.Function)
      */
     @Override
     public <R> LazyPOrderedSetX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyPOrderedSetX<R>)super.trampoline(mapper);
+        return (LazyPOrderedSetX<R>) super.trampoline(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#slice(long, long)
      */
     @Override
     public LazyPOrderedSetX<T> slice(long from, long to) {
-       return (LazyPOrderedSetX<T>)super.slice(from, to);
+        return (LazyPOrderedSetX<T>) super.slice(from, to);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int)
      */
     @Override
     public LazyPOrderedSetX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyPOrderedSetX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyPOrderedSetX<ListX<T>>) super.grouped(groupSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function,
+     * java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyPOrderedSetX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyPOrderedSetX)super.grouped(classifier, downstream);
+
+        return (LazyPOrderedSetX) super.grouped(classifier, downstream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function)
      */
     @Override
     public <K> LazyPOrderedSetX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyPOrderedSetX)super.grouped(classifier);
+
+        return (LazyPOrderedSetX) super.grouped(classifier);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable)
      */
     @Override
     public <U> LazyPOrderedSetX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyPOrderedSetX)super.zip(other);
+
+        return (LazyPOrderedSetX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPOrderedSetX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyPOrderedSetX<R>)super.zip(other, zipper);
+    public <U, R> LazyPOrderedSetX<R> zip(Iterable<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPOrderedSetX<R>) super.zip(other, zipper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int)
      */
     @Override
     public LazyPOrderedSetX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyPOrderedSetX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyPOrderedSetX<ListX<T>>) super.sliding(windowSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int, int)
      */
     @Override
     public LazyPOrderedSetX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyPOrderedSetX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyPOrderedSetX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPOrderedSetX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyPOrderedSetX<T>)super.scanLeft(monoid);
+
+        return (LazyPOrderedSetX<T>) super.scanLeft(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPOrderedSetX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyPOrderedSetX<U>) super.scanLeft(seed, function);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPOrderedSetX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyPOrderedSetX<T>)super.scanRight(monoid);
+
+        return (LazyPOrderedSetX<T>) super.scanRight(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPOrderedSetX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyPOrderedSetX<U>)super.scanRight(identity, combiner);
+
+        return (LazyPOrderedSetX<U>) super.scanRight(identity, combiner);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyPOrderedSetX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyPOrderedSetX<T>)super.sorted(function);
+
+        return (LazyPOrderedSetX<T>) super.sorted(function);
     }
-    
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusLazy(java.lang.Object)
      */
     @Override
     public LazyPOrderedSetX<T> plusLazy(T e) {
-       
-        return (LazyPOrderedSetX<T>)super.plusLazy(e);
+
+        return (LazyPOrderedSetX<T>) super.plusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPOrderedSetX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyPOrderedSetX<T>)super.plusAllLazy(list);
+
+        return (LazyPOrderedSetX<T>) super.plusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusLazy(java.lang.Object)
      */
     @Override
     public LazyPOrderedSetX<T> minusLazy(Object e) {
-       
-        return (LazyPOrderedSetX<T>)super.minusLazy(e);
+
+        return (LazyPOrderedSetX<T>) super.minusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPOrderedSetX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyPOrderedSetX<T>)super.minusAllLazy(list);
+
+        return (LazyPOrderedSetX<T>) super.minusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(int)
      */
     @Override
     public LazyPStackX<T> cycle(int times) {
-       return LazyPStackX.fromPublisher(Flux.from(this.stream().cycle(times)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycle(times)));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
      */
     @Override
     public LazyPStackX<T> cycle(Monoid<T> m, int times) {
-        return LazyPStackX.fromPublisher(Flux.from(this.stream().cycle(m,times)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycle(m, times)));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> cycleWhile(Predicate<? super T> predicate) {
-       return LazyPStackX.fromPublisher(Flux.from(this.stream().cycleWhile(predicate)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycleWhile(predicate)));
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> cycleUntil(Predicate<? super T> predicate) {
-        return LazyPStackX.fromPublisher(Flux.from(this.stream().cycleUntil(predicate)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycleUntil(predicate)));
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
      */
     @Override
     public <U> LazyPOrderedSetX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyPOrderedSetX)super.zip(other);
+
+        return (LazyPOrderedSetX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip3(java.util.stream.Stream,
+     * java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyPOrderedSetX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyPOrderedSetX)super.zip3(second, third);
+
+        return (LazyPOrderedSetX) super.zip3(second, third);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip4(java.util.stream.Stream,
+     * java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
-    public <T2, T3, T4> LazyPOrderedSetX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
-            Stream<? extends T4> fourth) {
-       
-        return (LazyPOrderedSetX)super.zip4(second, third, fourth);
+    public <T2, T3, T4> LazyPOrderedSetX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second,
+            Stream<? extends T3> third, Stream<? extends T4> fourth) {
+
+        return (LazyPOrderedSetX) super.zip4(second, third, fourth);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zipWithIndex()
      */
     @Override
     public LazyPOrderedSetX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyPOrderedSetX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyPOrderedSetX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#distinct()
      */
     @Override
     public LazyPOrderedSetX<T> distinct() {
-       
-        return (LazyPOrderedSetX<T>)super.distinct();
+
+        return (LazyPOrderedSetX<T>) super.distinct();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted()
      */
     @Override
     public LazyPOrderedSetX<T> sorted() {
-       
-        return (LazyPOrderedSetX<T>)super.sorted();
+
+        return (LazyPOrderedSetX<T>) super.sorted();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.Comparator)
      */
     @Override
     public LazyPOrderedSetX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyPOrderedSetX<T>)super.sorted(c);
+
+        return (LazyPOrderedSetX<T>) super.sorted(c);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyPOrderedSetX<T>)super.skipWhile(p);
+
+        return (LazyPOrderedSetX<T>) super.skipWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyPOrderedSetX<T>)super.skipUntil(p);
+
+        return (LazyPOrderedSetX<T>) super.skipUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyPOrderedSetX<T>)super.limitWhile(p);
+
+        return (LazyPOrderedSetX<T>) super.limitWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyPOrderedSetX<T>)super.limitUntil(p);
+
+        return (LazyPOrderedSetX<T>) super.limitUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#intersperse(java.lang.Object)
      */
     @Override
     public LazyPOrderedSetX<T> intersperse(T value) {
-       
-        return (LazyPOrderedSetX<T>)super.intersperse(value);
+
+        return (LazyPOrderedSetX<T>) super.intersperse(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle()
      */
     @Override
     public LazyPOrderedSetX<T> shuffle() {
-       
-        return (LazyPOrderedSetX<T>)super.shuffle();
+
+        return (LazyPOrderedSetX<T>) super.shuffle();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipLast(int)
      */
     @Override
     public LazyPOrderedSetX<T> skipLast(int num) {
-       
-        return (LazyPOrderedSetX<T>)super.skipLast(num);
+
+        return (LazyPOrderedSetX<T>) super.skipLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitLast(int)
      */
     @Override
     public LazyPOrderedSetX<T> limitLast(int num) {
-       
-        return (LazyPOrderedSetX<T>)super.limitLast(num);
+
+        return (LazyPOrderedSetX<T>) super.limitLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmpty(java.lang.Object)
      */
     @Override
     public LazyPOrderedSetX<T> onEmpty(T value) {
-       
-        return (LazyPOrderedSetX<T>)super.onEmpty(value);
+
+        return (LazyPOrderedSetX<T>) super.onEmpty(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
      */
     @Override
     public LazyPOrderedSetX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyPOrderedSetX<T>)super.onEmptyGet(supplier);
+
+        return (LazyPOrderedSetX<T>) super.onEmptyGet(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyPOrderedSetX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyPOrderedSetX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyPOrderedSetX<T>) super.onEmptyThrow(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle(java.util.Random)
      */
     @Override
     public LazyPOrderedSetX<T> shuffle(Random random) {
-       
-        return (LazyPOrderedSetX<T>)super.shuffle(random);
+
+        return (LazyPOrderedSetX<T>) super.shuffle(random);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#ofType(java.lang.Class)
      */
     @Override
     public <U> LazyPOrderedSetX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyPOrderedSetX<U>)super.ofType(type);
+
+        return (LazyPOrderedSetX<U>) super.ofType(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyPOrderedSetX<T>)super.filterNot(fn);
+
+        return (LazyPOrderedSetX<T>) super.filterNot(fn);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#notNull()
      */
     @Override
     public LazyPOrderedSetX<T> notNull() {
-       
-        return (LazyPOrderedSetX<T>)super.notNull();
+
+        return (LazyPOrderedSetX<T>) super.notNull();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
      */
     @Override
     public LazyPOrderedSetX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyPOrderedSetX<T>)(super.removeAll(stream));
+
+        return (LazyPOrderedSetX<T>) (super.removeAll(stream));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPOrderedSetX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyPOrderedSetX<T>)super.removeAll(stream);
+
+        return (LazyPOrderedSetX<T>) super.removeAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Iterable)
      */
     @Override
     public LazyPOrderedSetX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyPOrderedSetX<T>)super.removeAll(it);
+
+        return (LazyPOrderedSetX<T>) super.removeAll(it);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Object[])
      */
     @Override
     public LazyPOrderedSetX<T> removeAll(T... values) {
-       
-        return (LazyPOrderedSetX<T>)super.removeAll(values);
+
+        return (LazyPOrderedSetX<T>) super.removeAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Iterable)
      */
     @Override
     public LazyPOrderedSetX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyPOrderedSetX<T>)super.retainAll(it);
+
+        return (LazyPOrderedSetX<T>) super.retainAll(it);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
      */
     @Override
     public LazyPOrderedSetX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyPOrderedSetX<T>)super.retainAll(stream);
+
+        return (LazyPOrderedSetX<T>) super.retainAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPOrderedSetX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyPOrderedSetX<T>)super.retainAll(stream);
+
+        return (LazyPOrderedSetX<T>) super.retainAll(stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Object[])
      */
     @Override
     public LazyPOrderedSetX<T> retainAll(T... values) {
-       
-        return (LazyPOrderedSetX<T>)super.retainAll(values);
+
+        return (LazyPOrderedSetX<T>) super.retainAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cast(java.lang.Class)
      */
     @Override
     public <U> LazyPOrderedSetX<U> cast(Class<? extends U> type) {
-       
-        return (LazyPOrderedSetX<U>)super.cast(type);
+
+        return (LazyPOrderedSetX<U>) super.cast(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
     public <R> LazyPOrderedSetX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyPOrderedSetX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyPOrderedSetX<R>) super.patternMatch(case1, otherwise);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#permutations()
      */
     @Override
     public LazyPOrderedSetX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyPOrderedSetX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyPOrderedSetX<ReactiveSeq<T>>) super.permutations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations(int)
      */
     @Override
     public LazyPOrderedSetX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyPOrderedSetX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyPOrderedSetX<ReactiveSeq<T>>) super.combinations(size);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations()
      */
     @Override
     public LazyPOrderedSetX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyPOrderedSetX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyPOrderedSetX<ReactiveSeq<T>>) super.combinations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPOrderedSetX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyPOrderedSetX<C>)super.grouped(size, supplier);
+
+        return (LazyPOrderedSetX<C>) super.grouped(size, supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPOrderedSetX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyPOrderedSetX<ListX<T>>) super.groupedUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPOrderedSetX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPOrderedSetX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyPOrderedSetX<ListX<T>>) super.groupedWhile(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPOrderedSetX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPOrderedSetX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyPOrderedSetX<C>) super.groupedWhile(predicate, factory);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPOrderedSetX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPOrderedSetX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyPOrderedSetX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** PStackX methods **/
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int, java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int,
+     * java.lang.Object)
      */
-    public LazyPOrderedSetX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyPOrderedSetX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    
- 
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyPOrderedSetX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyPOrderedSetX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyPOrderedSetX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyPOrderedSetX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyPOrderedSetX)super.peek(c);
+
+        return (LazyPOrderedSetX) super.peek(c);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazyPOrderedSetX<R> zip(Seq<? extends U> other,
             BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyPOrderedSetX<R>)super.zip(other, zipper);
+
+        return (LazyPOrderedSetX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazyPOrderedSetX<R> zip(Stream<? extends U> other,
             BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyPOrderedSetX<R>)super.zip(other, zipper);
+
+        return (LazyPOrderedSetX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyPOrderedSetX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyPOrderedSetX)super.zip(other);
+
+        return (LazyPOrderedSetX) super.zip(other);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyPOrderedSetX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyPOrderedSetX<R>)super.zip(fn, publisher);
+
+        return (LazyPOrderedSetX<R>) super.zip(fn, publisher);
     }
- 
-   
-  
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyPOrderedSetX<T> onEmptySwitch(Supplier<? extends POrderedSet<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
-       
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
+
     }
-    
 
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(
+     * Collection)
      */
     @Override
     public <R> LazyPOrderedSetX<R> unit(Collection<R> col) {
-       
+
         return fromIterable(col);
     }
-    
+
     @Override
     public <R> LazyPOrderedSetX<R> unit(R value) {
         return singleton(value);
     }
 
     @Override
-    public<R> LazyPOrderedSetX<R> unitIterator(Iterator<R> it) {
+    public <R> LazyPOrderedSetX<R> unitIterator(Iterator<R> it) {
         return fromIterable(() -> it);
     }
 
     @Override
     public <R> LazyPOrderedSetX<R> emptyUnit() {
-       
+
         return LazyPOrderedSetX.<R> empty();
     }
 
@@ -1288,15 +1593,21 @@ public LazyPOrderedSetX<T> toPVector() {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyPOrderedSetX<T> plusInOrder(T e) {
         return plus(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#stream()
      */
     @Override
@@ -1304,43 +1615,56 @@ public ReactiveSeq<T> stream() {
 
         return ReactiveSeq.fromIterable(this);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <X> LazyPOrderedSetX<X> from(Collection<X> col) {
         return fromIterable(col);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
      */
     @Override
     public <T> Reducer<POrderedSet<T>> monoid() {
-       
+
         return Reducers.toPOrderedSet();
 
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plus(java.lang.Object)
      */
     @Override
     public LazyPOrderedSetX<T> plus(T e) {
-        return new LazyPOrderedSetX<T>(getSet().plus(e),this.collector);
+        return new LazyPOrderedSetX<T>(
+                                       getSet().plus(e), this.collector);
     }
-    
-  
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plusAll(java.util.Collection)
      */
     @Override
-    public  LazyPOrderedSetX<T> plusAll(Collection<? extends T> list) {
-        return new LazyPOrderedSetX<T>(getSet().plusAll(list),this.collector);
+    public LazyPOrderedSetX<T> plusAll(Collection<? extends T> list) {
+        return new LazyPOrderedSetX<T>(
+                                       getSet().plusAll(list), this.collector);
     }
-    
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.POrderedSet#get(int)
      */
     @Override
@@ -1348,35 +1672,38 @@ public T get(int index) {
         return getSet().get(index);
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.POrderedSet#indexOf(java.lang.Object)
      */
     @Override
     public int indexOf(Object o) {
         return getSet().indexOf(o);
     }
-    
-    
-    
-    
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minus(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minus(java.lang.Object)
      */
     @Override
-    public  LazyPOrderedSetX<T> minus(Object e) {
+    public LazyPOrderedSetX<T> minus(Object e) {
         PCollection<T> res = getSet().minus(e);
-        return LazyPOrderedSetX.fromIterable(this.collector,res);
-        
+        return LazyPOrderedSetX.fromIterable(this.collector, res);
+
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAll(java.util.Collection)
      */
     public LazyPOrderedSetX<T> minusAll(Collection<?> list) {
         PCollection<T> res = getSet().minusAll(list);
-        return LazyPOrderedSetX.fromIterable(this.collector,res);
+        return LazyPOrderedSetX.fromIterable(this.collector, res);
     }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPQueueX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPQueueX.java
index 46ad6844..0e4eacfc 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPQueueX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPQueueX.java
@@ -45,6 +45,7 @@
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended Queue type {@see java.util.Queue}
  * This makes use of PQueue (@see org.pcollections.PQueue) from PCollectons.
@@ -73,24 +74,23 @@
  *
  * @param <T> the type of elements held in this collection
  */
-@AllArgsConstructor(access=AccessLevel.PRIVATE)
-public class LazyPQueueX<T> extends AbstractFluentCollectionX<T> implements PQueueX<T> {
-    private final  LazyFluentCollection<T,PQueue<T>> lazy;
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class LazyPQueueX<T> extends AbstractFluentCollectionX<T>implements PQueueX<T> {
+    private final LazyFluentCollection<T, PQueue<T>> lazy;
     @Getter
     private final Reducer<PQueue<T>> collector;
-   
 
-  
-    
     /**
      * Create a LazyPStackX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyPStackX
      */
-    public static <T> LazyPQueueX<T> fromStreamS(Stream<T> stream){
-        return new LazyPQueueX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyPQueueX<T> fromStreamS(Stream<T> stream) {
+        return new LazyPQueueX<T>(
+                                  Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyPStackX that contains the Integers between start and end
      * 
@@ -146,7 +146,7 @@ public static <U, T> LazyPQueueX<T> unfold(U seed, Function<? super U, Optional<
     public static <T> LazyPQueueX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -159,10 +159,9 @@ public static <T> LazyPQueueX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyPQueueX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyPStackX
      */
@@ -170,14 +169,13 @@ public static <T> LazyPQueueX<T> iterate(long limit, final T seed, final UnaryOp
         return Collectors.toCollection(() -> LazyPQueueX.of());
     }
 
-   
-
     /**
      * @return An empty LazyPStackX
      */
     public static <T> LazyPQueueX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -198,8 +196,9 @@ public static <T> LazyPQueueX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyPQueueX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -253,42 +252,54 @@ public static <T> LazyPQueueX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyPQueueX<T> fromIterable(Reducer<PQueue<T>> collector, Iterable<T> it) {
         if (it instanceof LazyPQueueX)
             return (LazyPQueueX<T>) it;
-       
+
         if (it instanceof PQueue)
             return new LazyPQueueX<T>(
-                                    (PQueue<T>) it, collector);
-        
+                                      (PQueue<T>) it, collector);
+
         return new LazyPQueueX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                  Flux.fromIterable(it), collector);
     }
-    private LazyPQueueX(PQueue<T> list,Reducer<PQueue<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PQueue<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPQueueX(PQueue<T> list, Reducer<PQueue<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PQueue<T>>(
+                                                               list, null, collector);
+        this.collector = collector;
     }
-    private LazyPQueueX(boolean efficientOps,PQueue<T> list,Reducer<PQueue<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PQueue<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPQueueX(boolean efficientOps, PQueue<T> list, Reducer<PQueue<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PQueue<T>>(
+                                                               list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyPQueueX(PQueue<T> list){
+
+    private LazyPQueueX(PQueue<T> list) {
         this.collector = Reducers.toPQueue();
-        this.lazy = new PersistentLazyCollection<T,PQueue<T>>(list,null,Reducers.toPQueue());
+        this.lazy = new PersistentLazyCollection<T, PQueue<T>>(
+                                                               list, null, Reducers.toPQueue());
     }
-    private LazyPQueueX(Flux<T> stream,Reducer<PQueue<T>> collector){
+
+    private LazyPQueueX(Flux<T> stream, Reducer<PQueue<T>> collector) {
         this.collector = collector;
-        this.lazy = new PersistentLazyCollection<>(null,stream,Reducers.toPQueue());
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, Reducers.toPQueue());
     }
-    private LazyPQueueX(Flux<T> stream){
+
+    private LazyPQueueX(Flux<T> stream) {
         this.collector = Reducers.toPQueue();
-        this.lazy = new PersistentLazyCollection<>(null,stream,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, collector);
     }
-    private LazyPQueueX(){
+
+    private LazyPQueueX() {
         this.collector = Reducers.toPQueue();
-        this.lazy = new PersistentLazyCollection<>((PQueue)this.collector.zero(),null,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   (PQueue) this.collector.zero(), null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -296,7 +307,9 @@ public void forEach(Consumer<? super T> action) {
         getQueue().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -304,7 +317,9 @@ public Iterator<T> iterator() {
         return getQueue().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -312,7 +327,9 @@ public int size() {
         return getQueue().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -320,7 +337,9 @@ public boolean contains(Object e) {
         return getQueue().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -328,9 +347,9 @@ public boolean equals(Object o) {
         return getQueue().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -338,7 +357,9 @@ public boolean isEmpty() {
         return getQueue().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -346,7 +367,9 @@ public int hashCode() {
         return getQueue().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -354,7 +377,9 @@ public Object[] toArray() {
         return getQueue().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -362,7 +387,9 @@ public boolean removeAll(Collection<?> c) {
         return getQueue().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -370,7 +397,9 @@ public <T> T[] toArray(T[] a) {
         return getQueue().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -378,7 +407,9 @@ public boolean add(T e) {
         return getQueue().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -386,7 +417,9 @@ public boolean remove(Object o) {
         return getQueue().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -394,7 +427,9 @@ public boolean containsAll(Collection<?> c) {
         return getQueue().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -402,7 +437,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getQueue().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -410,7 +447,9 @@ public boolean retainAll(Collection<?> c) {
         return getQueue().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -418,8 +457,9 @@ public void clear() {
         getQueue().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -427,7 +467,9 @@ public String toString() {
         return getQueue().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -435,851 +477,1108 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getQueue().removeIf(filter);
     }
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getQueue().parallelStream();
     }
-    
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getQueue().spliterator();
     }
-   
+
     /**
      * @return PQueue
      */
     private PQueue<T> getQueue() {
         return lazy.get();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyPQueueX<X> stream(Flux<X> stream){
-        return new LazyPQueueX<X>(stream);
+    public <X> LazyPQueueX<X> stream(Flux<X> stream) {
+        return new LazyPQueueX<X>(
+                                  stream);
     }
-   
-    
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flux()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flux()
      */
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combine(java.util.function.BiPredicate,
+     * java.util.function.BinaryOperator)
      */
     @Override
     public LazyPQueueX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyPQueueX<T>)super.combine(predicate, op);
+
+        return (LazyPQueueX<T>) super.combine(predicate, op);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#reverse()
      */
     @Override
     public LazyPQueueX<T> reverse() {
-       
-        return(LazyPQueueX<T>)super.reverse();
+
+        return (LazyPQueueX<T>) super.reverse();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filter(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyPQueueX<T>)super.filter(pred);
+
+        return (LazyPQueueX<T>) super.filter(pred);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#map(java.util.function.Function)
      */
     @Override
     public <R> LazyPQueueX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyPQueueX<R>)super.map(mapper);
+
+        return (LazyPQueueX<R>) super.map(mapper);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flatMap(java.util.function.Function)
      */
     @Override
     public <R> LazyPQueueX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyPQueueX<R>)super.flatMap(mapper);
+        return (LazyPQueueX<R>) super.flatMap(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limit(long)
      */
     @Override
     public LazyPQueueX<T> limit(long num) {
-       return (LazyPQueueX<T>)super.limit(num);
+        return (LazyPQueueX<T>) super.limit(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skip(long)
      */
     @Override
     public LazyPQueueX<T> skip(long num) {
-       return (LazyPQueueX<T>)super.skip(num);
+        return (LazyPQueueX<T>) super.skip(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeRight(int)
      */
     @Override
     public LazyPQueueX<T> takeRight(int num) {
-       return (LazyPQueueX<T>)super.takeRight(num);
+        return (LazyPQueueX<T>) super.takeRight(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropRight(int)
      */
     @Override
     public LazyPQueueX<T> dropRight(int num) {
-       return (LazyPQueueX<T>)super.dropRight(num);
+        return (LazyPQueueX<T>) super.dropRight(num);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyPQueueX<T>)super.takeWhile(p);
+        return (LazyPQueueX<T>) super.takeWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyPQueueX<T>)super.dropWhile(p);
+        return (LazyPQueueX<T>) super.dropWhile(p);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyPQueueX<T>)super.takeUntil(p);
+        return (LazyPQueueX<T>) super.takeUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyPQueueX<T>)super.dropUntil(p);
+        return (LazyPQueueX<T>) super.dropUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#trampoline(java.util.function.Function)
      */
     @Override
     public <R> LazyPQueueX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyPQueueX<R>)super.trampoline(mapper);
+        return (LazyPQueueX<R>) super.trampoline(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#slice(long, long)
      */
     @Override
     public LazyPQueueX<T> slice(long from, long to) {
-       return (LazyPQueueX<T>)super.slice(from, to);
+        return (LazyPQueueX<T>) super.slice(from, to);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int)
      */
     @Override
     public LazyPQueueX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyPQueueX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyPQueueX<ListX<T>>) super.grouped(groupSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function,
+     * java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyPQueueX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyPQueueX)super.grouped(classifier, downstream);
+
+        return (LazyPQueueX) super.grouped(classifier, downstream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function)
      */
     @Override
     public <K> LazyPQueueX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyPQueueX)super.grouped(classifier);
+
+        return (LazyPQueueX) super.grouped(classifier);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable)
      */
     @Override
     public <U> LazyPQueueX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyPQueueX)super.zip(other);
+
+        return (LazyPQueueX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPQueueX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyPQueueX<R>)super.zip(other, zipper);
+    public <U, R> LazyPQueueX<R> zip(Iterable<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPQueueX<R>) super.zip(other, zipper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int)
      */
     @Override
     public LazyPQueueX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyPQueueX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyPQueueX<ListX<T>>) super.sliding(windowSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int, int)
      */
     @Override
     public LazyPQueueX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyPQueueX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyPQueueX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPQueueX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyPQueueX<T>)super.scanLeft(monoid);
+
+        return (LazyPQueueX<T>) super.scanLeft(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPQueueX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyPQueueX<U>) super.scanLeft(seed, function);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPQueueX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyPQueueX<T>)super.scanRight(monoid);
+
+        return (LazyPQueueX<T>) super.scanRight(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPQueueX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyPQueueX<U>)super.scanRight(identity, combiner);
+
+        return (LazyPQueueX<U>) super.scanRight(identity, combiner);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyPQueueX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyPQueueX<T>)super.sorted(function);
+
+        return (LazyPQueueX<T>) super.sorted(function);
     }
-    
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusLazy(java.lang.Object)
      */
     @Override
     public LazyPQueueX<T> plusLazy(T e) {
-       
-        return (LazyPQueueX<T>)super.plusLazy(e);
+
+        return (LazyPQueueX<T>) super.plusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPQueueX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyPQueueX<T>)super.plusAllLazy(list);
+
+        return (LazyPQueueX<T>) super.plusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusLazy(java.lang.Object)
      */
     @Override
     public LazyPQueueX<T> minusLazy(Object e) {
-       
-        return (LazyPQueueX<T>)super.minusLazy(e);
+
+        return (LazyPQueueX<T>) super.minusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPQueueX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyPQueueX<T>)super.minusAllLazy(list);
+
+        return (LazyPQueueX<T>) super.minusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(int)
      */
     @Override
     public LazyPQueueX<T> cycle(int times) {
-       
-        return (LazyPQueueX<T>)super.cycle(times);
+
+        return (LazyPQueueX<T>) super.cycle(times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
      */
     @Override
     public LazyPQueueX<T> cycle(Monoid<T> m, int times) {
-       
-        return (LazyPQueueX<T>)super.cycle(m, times);
+
+        return (LazyPQueueX<T>) super.cycle(m, times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPQueueX<T>)super.cycleWhile(predicate);
+
+        return (LazyPQueueX<T>) super.cycleWhile(predicate);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPQueueX<T>)super.cycleUntil(predicate);
+
+        return (LazyPQueueX<T>) super.cycleUntil(predicate);
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
      */
     @Override
     public <U> LazyPQueueX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyPQueueX)super.zip(other);
+
+        return (LazyPQueueX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip3(java.util.stream.Stream,
+     * java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyPQueueX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyPQueueX)super.zip3(second, third);
+
+        return (LazyPQueueX) super.zip3(second, third);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip4(java.util.stream.Stream,
+     * java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazyPQueueX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazyPQueueX)super.zip4(second, third, fourth);
+
+        return (LazyPQueueX) super.zip4(second, third, fourth);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zipWithIndex()
      */
     @Override
     public LazyPQueueX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyPQueueX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyPQueueX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#distinct()
      */
     @Override
     public LazyPQueueX<T> distinct() {
-       
-        return (LazyPQueueX<T>)super.distinct();
+
+        return (LazyPQueueX<T>) super.distinct();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted()
      */
     @Override
     public LazyPQueueX<T> sorted() {
-       
-        return (LazyPQueueX<T>)super.sorted();
+
+        return (LazyPQueueX<T>) super.sorted();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.Comparator)
      */
     @Override
     public LazyPQueueX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyPQueueX<T>)super.sorted(c);
+
+        return (LazyPQueueX<T>) super.sorted(c);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyPQueueX<T>)super.skipWhile(p);
+
+        return (LazyPQueueX<T>) super.skipWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyPQueueX<T>)super.skipUntil(p);
+
+        return (LazyPQueueX<T>) super.skipUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyPQueueX<T>)super.limitWhile(p);
+
+        return (LazyPQueueX<T>) super.limitWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyPQueueX<T>)super.limitUntil(p);
+
+        return (LazyPQueueX<T>) super.limitUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#intersperse(java.lang.Object)
      */
     @Override
     public LazyPQueueX<T> intersperse(T value) {
-       
-        return (LazyPQueueX<T>)super.intersperse(value);
+
+        return (LazyPQueueX<T>) super.intersperse(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle()
      */
     @Override
     public LazyPQueueX<T> shuffle() {
-       
-        return (LazyPQueueX<T>)super.shuffle();
+
+        return (LazyPQueueX<T>) super.shuffle();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipLast(int)
      */
     @Override
     public LazyPQueueX<T> skipLast(int num) {
-       
-        return (LazyPQueueX<T>)super.skipLast(num);
+
+        return (LazyPQueueX<T>) super.skipLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitLast(int)
      */
     @Override
     public LazyPQueueX<T> limitLast(int num) {
-       
-        return (LazyPQueueX<T>)super.limitLast(num);
+
+        return (LazyPQueueX<T>) super.limitLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmpty(java.lang.Object)
      */
     @Override
     public LazyPQueueX<T> onEmpty(T value) {
-       
-        return (LazyPQueueX<T>)super.onEmpty(value);
+
+        return (LazyPQueueX<T>) super.onEmpty(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
      */
     @Override
     public LazyPQueueX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyPQueueX<T>)super.onEmptyGet(supplier);
+
+        return (LazyPQueueX<T>) super.onEmptyGet(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyPQueueX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyPQueueX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyPQueueX<T>) super.onEmptyThrow(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle(java.util.Random)
      */
     @Override
     public LazyPQueueX<T> shuffle(Random random) {
-       
-        return (LazyPQueueX<T>)super.shuffle(random);
+
+        return (LazyPQueueX<T>) super.shuffle(random);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#ofType(java.lang.Class)
      */
     @Override
     public <U> LazyPQueueX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyPQueueX<U>)super.ofType(type);
+
+        return (LazyPQueueX<U>) super.ofType(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyPQueueX<T>)super.filterNot(fn);
+
+        return (LazyPQueueX<T>) super.filterNot(fn);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#notNull()
      */
     @Override
     public LazyPQueueX<T> notNull() {
-       
-        return (LazyPQueueX<T>)super.notNull();
+
+        return (LazyPQueueX<T>) super.notNull();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
      */
     @Override
     public LazyPQueueX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyPQueueX<T>)(super.removeAll(stream));
+
+        return (LazyPQueueX<T>) (super.removeAll(stream));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPQueueX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyPQueueX<T>)super.removeAll(stream);
+
+        return (LazyPQueueX<T>) super.removeAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Iterable)
      */
     @Override
     public LazyPQueueX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyPQueueX<T>)super.removeAll(it);
+
+        return (LazyPQueueX<T>) super.removeAll(it);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Object[])
      */
     @Override
     public LazyPQueueX<T> removeAll(T... values) {
-       
-        return (LazyPQueueX<T>)super.removeAll(values);
+
+        return (LazyPQueueX<T>) super.removeAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Iterable)
      */
     @Override
     public LazyPQueueX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyPQueueX<T>)super.retainAll(it);
+
+        return (LazyPQueueX<T>) super.retainAll(it);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
      */
     @Override
     public LazyPQueueX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyPQueueX<T>)super.retainAll(stream);
+
+        return (LazyPQueueX<T>) super.retainAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPQueueX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyPQueueX<T>)super.retainAll(stream);
+
+        return (LazyPQueueX<T>) super.retainAll(stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Object[])
      */
     @Override
     public LazyPQueueX<T> retainAll(T... values) {
-       
-        return (LazyPQueueX<T>)super.retainAll(values);
+
+        return (LazyPQueueX<T>) super.retainAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cast(java.lang.Class)
      */
     @Override
     public <U> LazyPQueueX<U> cast(Class<? extends U> type) {
-       
-        return (LazyPQueueX<U>)super.cast(type);
+
+        return (LazyPQueueX<U>) super.cast(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
     public <R> LazyPQueueX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyPQueueX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyPQueueX<R>) super.patternMatch(case1, otherwise);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#permutations()
      */
     @Override
     public LazyPQueueX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyPQueueX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyPQueueX<ReactiveSeq<T>>) super.permutations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations(int)
      */
     @Override
     public LazyPQueueX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyPQueueX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyPQueueX<ReactiveSeq<T>>) super.combinations(size);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations()
      */
     @Override
     public LazyPQueueX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyPQueueX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyPQueueX<ReactiveSeq<T>>) super.combinations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPQueueX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyPQueueX<C>)super.grouped(size, supplier);
+
+        return (LazyPQueueX<C>) super.grouped(size, supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPQueueX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyPQueueX<ListX<T>>) super.groupedUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPQueueX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPQueueX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyPQueueX<ListX<T>>) super.groupedWhile(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPQueueX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPQueueX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyPQueueX<C>) super.groupedWhile(predicate, factory);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPQueueX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPQueueX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyPQueueX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** PStackX methods **/
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int, java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int,
+     * java.lang.Object)
      */
-    public LazyPQueueX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyPQueueX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    
- 
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyPQueueX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyPQueueX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyPQueueX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyPQueueX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyPQueueX)super.peek(c);
+
+        return (LazyPQueueX) super.peek(c);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPQueueX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyPQueueX<R>)super.zip(other, zipper);
+    public <U, R> LazyPQueueX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPQueueX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPQueueX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyPQueueX<R>)super.zip(other, zipper);
+    public <U, R> LazyPQueueX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPQueueX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyPQueueX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyPQueueX)super.zip(other);
+
+        return (LazyPQueueX) super.zip(other);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyPQueueX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyPQueueX<R>)super.zip(fn, publisher);
+
+        return (LazyPQueueX<R>) super.zip(fn, publisher);
     }
- 
-   
-  
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyPQueueX<T> onEmptySwitch(Supplier<? extends PQueue<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
-       
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
+
     }
-    
 
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(
+     * Collection)
      */
     @Override
     public <R> LazyPQueueX<R> unit(Collection<R> col) {
-       
+
         return fromIterable(col);
     }
-    
+
     @Override
     public <R> LazyPQueueX<R> unit(R value) {
         return singleton(value);
     }
 
     @Override
-    public<R> LazyPQueueX<R> unitIterator(Iterator<R> it) {
+    public <R> LazyPQueueX<R> unitIterator(Iterator<R> it) {
         return fromIterable(() -> it);
     }
 
     @Override
     public <R> LazyPQueueX<R> emptyUnit() {
-       
+
         return LazyPQueueX.<R> empty();
     }
 
@@ -1290,15 +1589,21 @@ public LazyPQueueX<T> toPVector() {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyPQueueX<T> plusInOrder(T e) {
         return plus(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#stream()
      */
     @Override
@@ -1306,84 +1611,101 @@ public ReactiveSeq<T> stream() {
 
         return ReactiveSeq.fromIterable(this);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <X> LazyPQueueX<X> from(Collection<X> col) {
         return fromIterable(col);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
      */
     @Override
     public <T> Reducer<PQueue<T>> monoid() {
-       
+
         return Reducers.toPQueue();
 
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plus(java.lang.Object)
      */
     @Override
     public LazyPQueueX<T> plus(T e) {
-        return new LazyPQueueX<T>(getQueue().plus(e),this.collector);
+        return new LazyPQueueX<T>(
+                                  getQueue().plus(e), this.collector);
     }
-    
-  
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plusAll(java.util.Collection)
      */
     @Override
-    public  LazyPQueueX<T> plusAll(Collection<? extends T> list) {
-        return new LazyPQueueX<T>(getQueue().plusAll(list),this.collector);
+    public LazyPQueueX<T> plusAll(Collection<? extends T> list) {
+        return new LazyPQueueX<T>(
+                                  getQueue().plusAll(list), this.collector);
     }
-    
 
-   
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PQueue#minus()
      */
     public LazyPQueueX<T> minus() {
-        return LazyPQueueX.fromIterable(this.collector,getQueue().minus());
+        return LazyPQueueX.fromIterable(this.collector, getQueue().minus());
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PQueue#offer(java.lang.Object)
      */
     public boolean offer(T o) {
         return getQueue().offer(o);
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PQueue#poll()
      */
     public T poll() {
         return getQueue().poll();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PQueue#remove()
      */
     public T remove() {
         return getQueue().remove();
     }
 
-   
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Queue#element()
      */
     public T element() {
         return getQueue().element();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Queue#peek()
      */
     @Override
@@ -1391,22 +1713,28 @@ public T peek() {
         return getQueue().peek();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minus(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minus(java.lang.Object)
      */
     @Override
-    public  LazyPQueueX<T> minus(Object e) {
+    public LazyPQueueX<T> minus(Object e) {
         PCollection<T> res = getQueue().minus(e);
-        return LazyPQueueX.fromIterable(this.collector,res);
-        
+        return LazyPQueueX.fromIterable(this.collector, res);
+
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAll(java.util.Collection)
      */
     public LazyPQueueX<T> minusAll(Collection<?> list) {
         PCollection<T> res = getQueue().minusAll(list);
-        return LazyPQueueX.fromIterable(this.collector,res);
+        return LazyPQueueX.fromIterable(this.collector, res);
     }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPSetX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPSetX.java
index bfb8ffc9..56863f75 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPSetX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPSetX.java
@@ -44,6 +44,7 @@
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended Set type {@see java.util.Set}
  * This makes use of PSet (@see org.pcollections.PSet) from PCollectons.
@@ -76,24 +77,23 @@
  *
  * @param <T> the type of elements held in this collection
  */
-@AllArgsConstructor(access=AccessLevel.PRIVATE)
-public class LazyPSetX<T> extends AbstractFluentCollectionX<T> implements PSetX<T> {
-    private final  LazyFluentCollection<T,PSet<T>> lazy;
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class LazyPSetX<T> extends AbstractFluentCollectionX<T>implements PSetX<T> {
+    private final LazyFluentCollection<T, PSet<T>> lazy;
     @Getter
     private final Reducer<PSet<T>> collector;
-   
 
-  
-    
     /**
      * Create a LazyPStackX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyPStackX
      */
-    public static <T> LazyPSetX<T> fromStreamS(Stream<T> stream){
-        return new LazyPSetX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyPSetX<T> fromStreamS(Stream<T> stream) {
+        return new LazyPSetX<T>(
+                                Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyPStackX that contains the Integers between start and end
      * 
@@ -149,7 +149,7 @@ public static <U, T> LazyPSetX<T> unfold(U seed, Function<? super U, Optional<Tu
     public static <T> LazyPSetX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -162,10 +162,9 @@ public static <T> LazyPSetX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyPSetX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyPStackX
      */
@@ -173,14 +172,13 @@ public static <T> LazyPSetX<T> iterate(long limit, final T seed, final UnaryOper
         return Collectors.toCollection(() -> LazyPSetX.of());
     }
 
-   
-
     /**
      * @return An empty LazyPStackX
      */
     public static <T> LazyPSetX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -201,8 +199,9 @@ public static <T> LazyPSetX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyPSetX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -256,42 +255,54 @@ public static <T> LazyPSetX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyPSetX<T> fromIterable(Reducer<PSet<T>> collector, Iterable<T> it) {
         if (it instanceof LazyPSetX)
             return (LazyPSetX<T>) it;
-       
+
         if (it instanceof PSet)
             return new LazyPSetX<T>(
                                     (PSet<T>) it, collector);
-        
+
         return new LazyPSetX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                Flux.fromIterable(it), collector);
     }
-    private LazyPSetX(PSet<T> list,Reducer<PSet<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PSet<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPSetX(PSet<T> list, Reducer<PSet<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PSet<T>>(
+                                                             list, null, collector);
+        this.collector = collector;
     }
-    private LazyPSetX(boolean efficientOps,PSet<T> list,Reducer<PSet<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PSet<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPSetX(boolean efficientOps, PSet<T> list, Reducer<PSet<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PSet<T>>(
+                                                             list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyPSetX(PSet<T> list){
+
+    private LazyPSetX(PSet<T> list) {
         this.collector = Reducers.toPSet();
-        this.lazy = new PersistentLazyCollection<T,PSet<T>>(list,null,Reducers.toPSet());
+        this.lazy = new PersistentLazyCollection<T, PSet<T>>(
+                                                             list, null, Reducers.toPSet());
     }
-    private LazyPSetX(Flux<T> stream,Reducer<PSet<T>> collector){
+
+    private LazyPSetX(Flux<T> stream, Reducer<PSet<T>> collector) {
         this.collector = collector;
-        this.lazy = new PersistentLazyCollection<>(null,stream,Reducers.toPSet());
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, Reducers.toPSet());
     }
-    private LazyPSetX(Flux<T> stream){
+
+    private LazyPSetX(Flux<T> stream) {
         this.collector = Reducers.toPSet();
-        this.lazy = new PersistentLazyCollection<>(null,stream,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, collector);
     }
-    private LazyPSetX(){
+
+    private LazyPSetX() {
         this.collector = Reducers.toPSet();
-        this.lazy = new PersistentLazyCollection<>((PSet)this.collector.zero(),null,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   (PSet) this.collector.zero(), null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -299,7 +310,9 @@ public void forEach(Consumer<? super T> action) {
         getSet().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -307,7 +320,9 @@ public Iterator<T> iterator() {
         return getSet().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -315,7 +330,9 @@ public int size() {
         return getSet().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -323,7 +340,9 @@ public boolean contains(Object e) {
         return getSet().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -331,9 +350,9 @@ public boolean equals(Object o) {
         return getSet().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -341,7 +360,9 @@ public boolean isEmpty() {
         return getSet().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -349,7 +370,9 @@ public int hashCode() {
         return getSet().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -357,7 +380,9 @@ public Object[] toArray() {
         return getSet().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -365,7 +390,9 @@ public boolean removeAll(Collection<?> c) {
         return getSet().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -373,7 +400,9 @@ public <T> T[] toArray(T[] a) {
         return getSet().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -381,7 +410,9 @@ public boolean add(T e) {
         return getSet().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -389,7 +420,9 @@ public boolean remove(Object o) {
         return getSet().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -397,7 +430,9 @@ public boolean containsAll(Collection<?> c) {
         return getSet().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -405,7 +440,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getSet().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -413,7 +450,9 @@ public boolean retainAll(Collection<?> c) {
         return getSet().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -421,8 +460,9 @@ public void clear() {
         getSet().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -430,7 +470,9 @@ public String toString() {
         return getSet().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -438,847 +480,1107 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getSet().removeIf(filter);
     }
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getSet().parallelStream();
     }
-    
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getSet().spliterator();
     }
-   
+
     /**
      * @return PQueue
      */
     private PSet<T> getSet() {
         return lazy.get();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyPSetX<X> stream(Flux<X> stream){
-        return new LazyPSetX<X>(stream);
+    public <X> LazyPSetX<X> stream(Flux<X> stream) {
+        return new LazyPSetX<X>(
+                                stream);
     }
-   
-    
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flux()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flux()
      */
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combine(java.util.function.BiPredicate,
+     * java.util.function.BinaryOperator)
      */
     @Override
     public LazyPSetX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyPSetX<T>)super.combine(predicate, op);
+
+        return (LazyPSetX<T>) super.combine(predicate, op);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#reverse()
      */
     @Override
     public LazyPSetX<T> reverse() {
-       
-        return(LazyPSetX<T>)super.reverse();
+
+        return (LazyPSetX<T>) super.reverse();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filter(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyPSetX<T>)super.filter(pred);
+
+        return (LazyPSetX<T>) super.filter(pred);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#map(java.util.function.Function)
      */
     @Override
     public <R> LazyPSetX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyPSetX<R>)super.map(mapper);
+
+        return (LazyPSetX<R>) super.map(mapper);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flatMap(java.util.function.Function)
      */
     @Override
     public <R> LazyPSetX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyPSetX<R>)super.flatMap(mapper);
+        return (LazyPSetX<R>) super.flatMap(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limit(long)
      */
     @Override
     public LazyPSetX<T> limit(long num) {
-       return (LazyPSetX<T>)super.limit(num);
+        return (LazyPSetX<T>) super.limit(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skip(long)
      */
     @Override
     public LazyPSetX<T> skip(long num) {
-       return (LazyPSetX<T>)super.skip(num);
+        return (LazyPSetX<T>) super.skip(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeRight(int)
      */
     @Override
     public LazyPSetX<T> takeRight(int num) {
-       return (LazyPSetX<T>)super.takeRight(num);
+        return (LazyPSetX<T>) super.takeRight(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropRight(int)
      */
     @Override
     public LazyPSetX<T> dropRight(int num) {
-       return (LazyPSetX<T>)super.dropRight(num);
+        return (LazyPSetX<T>) super.dropRight(num);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyPSetX<T>)super.takeWhile(p);
+        return (LazyPSetX<T>) super.takeWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyPSetX<T>)super.dropWhile(p);
+        return (LazyPSetX<T>) super.dropWhile(p);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyPSetX<T>)super.takeUntil(p);
+        return (LazyPSetX<T>) super.takeUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyPSetX<T>)super.dropUntil(p);
+        return (LazyPSetX<T>) super.dropUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#trampoline(java.util.function.Function)
      */
     @Override
     public <R> LazyPSetX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyPSetX<R>)super.trampoline(mapper);
+        return (LazyPSetX<R>) super.trampoline(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#slice(long, long)
      */
     @Override
     public LazyPSetX<T> slice(long from, long to) {
-       return (LazyPSetX<T>)super.slice(from, to);
+        return (LazyPSetX<T>) super.slice(from, to);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int)
      */
     @Override
     public LazyPSetX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyPSetX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyPSetX<ListX<T>>) super.grouped(groupSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function,
+     * java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyPSetX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyPSetX)super.grouped(classifier, downstream);
+
+        return (LazyPSetX) super.grouped(classifier, downstream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function)
      */
     @Override
     public <K> LazyPSetX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyPSetX)super.grouped(classifier);
+
+        return (LazyPSetX) super.grouped(classifier);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable)
      */
     @Override
     public <U> LazyPSetX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyPSetX)super.zip(other);
+
+        return (LazyPSetX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazyPSetX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyPSetX<R>)super.zip(other, zipper);
+
+        return (LazyPSetX<R>) super.zip(other, zipper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int)
      */
     @Override
     public LazyPSetX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyPSetX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyPSetX<ListX<T>>) super.sliding(windowSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int, int)
      */
     @Override
     public LazyPSetX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyPSetX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyPSetX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPSetX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyPSetX<T>)super.scanLeft(monoid);
+
+        return (LazyPSetX<T>) super.scanLeft(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPSetX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyPSetX<U>) super.scanLeft(seed, function);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPSetX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyPSetX<T>)super.scanRight(monoid);
+
+        return (LazyPSetX<T>) super.scanRight(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPSetX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyPSetX<U>)super.scanRight(identity, combiner);
+
+        return (LazyPSetX<U>) super.scanRight(identity, combiner);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyPSetX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyPSetX<T>)super.sorted(function);
+
+        return (LazyPSetX<T>) super.sorted(function);
     }
-    
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusLazy(java.lang.Object)
      */
     @Override
     public LazyPSetX<T> plusLazy(T e) {
-       
-        return (LazyPSetX<T>)super.plusLazy(e);
+
+        return (LazyPSetX<T>) super.plusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPSetX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyPSetX<T>)super.plusAllLazy(list);
+
+        return (LazyPSetX<T>) super.plusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusLazy(java.lang.Object)
      */
     @Override
     public LazyPSetX<T> minusLazy(Object e) {
-       
-        return (LazyPSetX<T>)super.minusLazy(e);
+
+        return (LazyPSetX<T>) super.minusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPSetX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyPSetX<T>)super.minusAllLazy(list);
+
+        return (LazyPSetX<T>) super.minusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(int)
      */
     @Override
     public LazyPStackX<T> cycle(int times) {
-       return LazyPStackX.fromPublisher(Flux.from(this.stream().cycle(times)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycle(times)));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
      */
     @Override
     public LazyPStackX<T> cycle(Monoid<T> m, int times) {
-        return LazyPStackX.fromPublisher(Flux.from(this.stream().cycle(m,times)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycle(m, times)));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> cycleWhile(Predicate<? super T> predicate) {
-       return LazyPStackX.fromPublisher(Flux.from(this.stream().cycleWhile(predicate)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycleWhile(predicate)));
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> cycleUntil(Predicate<? super T> predicate) {
-        return LazyPStackX.fromPublisher(Flux.from(this.stream().cycleUntil(predicate)));
+        return LazyPStackX.fromPublisher(Flux.from(this.stream()
+                                                       .cycleUntil(predicate)));
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
      */
     @Override
     public <U> LazyPSetX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyPSetX)super.zip(other);
+
+        return (LazyPSetX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip3(java.util.stream.Stream,
+     * java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyPSetX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyPSetX)super.zip3(second, third);
+
+        return (LazyPSetX) super.zip3(second, third);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip4(java.util.stream.Stream,
+     * java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazyPSetX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazyPSetX)super.zip4(second, third, fourth);
+
+        return (LazyPSetX) super.zip4(second, third, fourth);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zipWithIndex()
      */
     @Override
     public LazyPSetX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyPSetX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyPSetX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#distinct()
      */
     @Override
     public LazyPSetX<T> distinct() {
-       
-        return (LazyPSetX<T>)super.distinct();
+
+        return (LazyPSetX<T>) super.distinct();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted()
      */
     @Override
     public LazyPSetX<T> sorted() {
-       
-        return (LazyPSetX<T>)super.sorted();
+
+        return (LazyPSetX<T>) super.sorted();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.Comparator)
      */
     @Override
     public LazyPSetX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyPSetX<T>)super.sorted(c);
+
+        return (LazyPSetX<T>) super.sorted(c);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyPSetX<T>)super.skipWhile(p);
+
+        return (LazyPSetX<T>) super.skipWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyPSetX<T>)super.skipUntil(p);
+
+        return (LazyPSetX<T>) super.skipUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyPSetX<T>)super.limitWhile(p);
+
+        return (LazyPSetX<T>) super.limitWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyPSetX<T>)super.limitUntil(p);
+
+        return (LazyPSetX<T>) super.limitUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#intersperse(java.lang.Object)
      */
     @Override
     public LazyPSetX<T> intersperse(T value) {
-       
-        return (LazyPSetX<T>)super.intersperse(value);
+
+        return (LazyPSetX<T>) super.intersperse(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle()
      */
     @Override
     public LazyPSetX<T> shuffle() {
-       
-        return (LazyPSetX<T>)super.shuffle();
+
+        return (LazyPSetX<T>) super.shuffle();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipLast(int)
      */
     @Override
     public LazyPSetX<T> skipLast(int num) {
-       
-        return (LazyPSetX<T>)super.skipLast(num);
+
+        return (LazyPSetX<T>) super.skipLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitLast(int)
      */
     @Override
     public LazyPSetX<T> limitLast(int num) {
-       
-        return (LazyPSetX<T>)super.limitLast(num);
+
+        return (LazyPSetX<T>) super.limitLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmpty(java.lang.Object)
      */
     @Override
     public LazyPSetX<T> onEmpty(T value) {
-       
-        return (LazyPSetX<T>)super.onEmpty(value);
+
+        return (LazyPSetX<T>) super.onEmpty(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
      */
     @Override
     public LazyPSetX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyPSetX<T>)super.onEmptyGet(supplier);
+
+        return (LazyPSetX<T>) super.onEmptyGet(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyPSetX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyPSetX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyPSetX<T>) super.onEmptyThrow(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle(java.util.Random)
      */
     @Override
     public LazyPSetX<T> shuffle(Random random) {
-       
-        return (LazyPSetX<T>)super.shuffle(random);
+
+        return (LazyPSetX<T>) super.shuffle(random);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#ofType(java.lang.Class)
      */
     @Override
     public <U> LazyPSetX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyPSetX<U>)super.ofType(type);
+
+        return (LazyPSetX<U>) super.ofType(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyPSetX<T>)super.filterNot(fn);
+
+        return (LazyPSetX<T>) super.filterNot(fn);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#notNull()
      */
     @Override
     public LazyPSetX<T> notNull() {
-       
-        return (LazyPSetX<T>)super.notNull();
+
+        return (LazyPSetX<T>) super.notNull();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
      */
     @Override
     public LazyPSetX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyPSetX<T>)(super.removeAll(stream));
+
+        return (LazyPSetX<T>) (super.removeAll(stream));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPSetX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyPSetX<T>)super.removeAll(stream);
+
+        return (LazyPSetX<T>) super.removeAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Iterable)
      */
     @Override
     public LazyPSetX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyPSetX<T>)super.removeAll(it);
+
+        return (LazyPSetX<T>) super.removeAll(it);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Object[])
      */
     @Override
     public LazyPSetX<T> removeAll(T... values) {
-       
-        return (LazyPSetX<T>)super.removeAll(values);
+
+        return (LazyPSetX<T>) super.removeAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Iterable)
      */
     @Override
     public LazyPSetX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyPSetX<T>)super.retainAll(it);
+
+        return (LazyPSetX<T>) super.retainAll(it);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
      */
     @Override
     public LazyPSetX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyPSetX<T>)super.retainAll(stream);
+
+        return (LazyPSetX<T>) super.retainAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPSetX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyPSetX<T>)super.retainAll(stream);
+
+        return (LazyPSetX<T>) super.retainAll(stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Object[])
      */
     @Override
     public LazyPSetX<T> retainAll(T... values) {
-       
-        return (LazyPSetX<T>)super.retainAll(values);
+
+        return (LazyPSetX<T>) super.retainAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cast(java.lang.Class)
      */
     @Override
     public <U> LazyPSetX<U> cast(Class<? extends U> type) {
-       
-        return (LazyPSetX<U>)super.cast(type);
+
+        return (LazyPSetX<U>) super.cast(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
     public <R> LazyPSetX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyPSetX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyPSetX<R>) super.patternMatch(case1, otherwise);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#permutations()
      */
     @Override
     public LazyPSetX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyPSetX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyPSetX<ReactiveSeq<T>>) super.permutations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations(int)
      */
     @Override
     public LazyPSetX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyPSetX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyPSetX<ReactiveSeq<T>>) super.combinations(size);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations()
      */
     @Override
     public LazyPSetX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyPSetX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyPSetX<ReactiveSeq<T>>) super.combinations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPSetX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyPSetX<C>)super.grouped(size, supplier);
+
+        return (LazyPSetX<C>) super.grouped(size, supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPSetX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyPSetX<ListX<T>>) super.groupedUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPSetX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPSetX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyPSetX<ListX<T>>) super.groupedWhile(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPSetX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPSetX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyPSetX<C>) super.groupedWhile(predicate, factory);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPSetX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPSetX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyPSetX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** PStackX methods **/
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int, java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int,
+     * java.lang.Object)
      */
-    public LazyPSetX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyPSetX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    
- 
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyPSetX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyPSetX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyPSetX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyPSetX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyPSetX)super.peek(c);
+
+        return (LazyPSetX) super.peek(c);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPSetX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyPSetX<R>)super.zip(other, zipper);
+    public <U, R> LazyPSetX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPSetX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPSetX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyPSetX<R>)super.zip(other, zipper);
+    public <U, R> LazyPSetX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPSetX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyPSetX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyPSetX)super.zip(other);
+
+        return (LazyPSetX) super.zip(other);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyPSetX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyPSetX<R>)super.zip(fn, publisher);
+
+        return (LazyPSetX<R>) super.zip(fn, publisher);
     }
- 
-   
-  
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyPSetX<T> onEmptySwitch(Supplier<? extends PSet<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
-       
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
+
     }
-    
 
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(
+     * Collection)
      */
     @Override
     public <R> LazyPSetX<R> unit(Collection<R> col) {
-       
+
         return fromIterable(col);
     }
-    
+
     @Override
     public <R> LazyPSetX<R> unit(R value) {
         return singleton(value);
     }
 
     @Override
-    public<R> LazyPSetX<R> unitIterator(Iterator<R> it) {
+    public <R> LazyPSetX<R> unitIterator(Iterator<R> it) {
         return fromIterable(() -> it);
     }
 
     @Override
     public <R> LazyPSetX<R> emptyUnit() {
-       
+
         return LazyPSetX.<R> empty();
     }
 
@@ -1289,15 +1591,21 @@ public LazyPSetX<T> toPVector() {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyPSetX<T> plusInOrder(T e) {
         return plus(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#stream()
      */
     @Override
@@ -1305,63 +1613,75 @@ public ReactiveSeq<T> stream() {
 
         return ReactiveSeq.fromIterable(this);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <X> LazyPSetX<X> from(Collection<X> col) {
         return fromIterable(col);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PQueueX#monoid()
      */
     @Override
     public <T> Reducer<PSet<T>> monoid() {
-       
+
         return Reducers.toPSet();
 
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plus(java.lang.Object)
      */
     @Override
     public LazyPSetX<T> plus(T e) {
-        return new LazyPSetX<T>(getSet().plus(e),this.collector);
+        return new LazyPSetX<T>(
+                                getSet().plus(e), this.collector);
     }
-    
-  
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plusAll(java.util.Collection)
      */
     @Override
-    public  LazyPSetX<T> plusAll(Collection<? extends T> list) {
-        return new LazyPSetX<T>(getSet().plusAll(list),this.collector);
+    public LazyPSetX<T> plusAll(Collection<? extends T> list) {
+        return new LazyPSetX<T>(
+                                getSet().plusAll(list), this.collector);
     }
-    
-
-   
-    
-    
-    
-    
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minus(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minus(java.lang.Object)
      */
     @Override
-    public  LazyPSetX<T> minus(Object e) {
+    public LazyPSetX<T> minus(Object e) {
         PCollection<T> res = getSet().minus(e);
-        return LazyPSetX.fromIterable(this.collector,res);
-        
+        return LazyPSetX.fromIterable(this.collector, res);
+
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAll(java.util.Collection)
      */
     public LazyPSetX<T> minusAll(Collection<?> list) {
         PCollection<T> res = getSet().minusAll(list);
-        return LazyPSetX.fromIterable(this.collector,res);
+        return LazyPSetX.fromIterable(this.collector, res);
     }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPStackX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPStackX.java
index 3d35dee4..bbe87d10 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPStackX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPStackX.java
@@ -44,6 +44,7 @@
 import lombok.Getter;
 import lombok.experimental.Wither;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended Persistent List type {@see java.util.List}
  * This makes use of PStack (@see org.pcollections.PStack) from PCollectons. PStack is a persistent analogue of  the 
@@ -72,30 +73,34 @@
  *
  * @param <T> the type of elements held in this collection
  */
-@AllArgsConstructor(access=AccessLevel.PRIVATE)
-public class LazyPStackX<T> extends AbstractFluentCollectionX<T> implements PStackX<T> {
-    private final  LazyFluentCollection<T,PStack<T>> lazy;
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class LazyPStackX<T> extends AbstractFluentCollectionX<T>implements PStackX<T> {
+    private final LazyFluentCollection<T, PStack<T>> lazy;
     @Getter
     private final Reducer<PStack<T>> collector;
-    @Wither @Getter
+    @Wither
+    @Getter
     private final boolean efficientOps;
 
-    public LazyPStackX<T> efficientOpsOn(){
+    public LazyPStackX<T> efficientOpsOn() {
         return this.withEfficientOps(true);
     }
-    public LazyPStackX<T> efficientOpsOff(){
+
+    public LazyPStackX<T> efficientOpsOff() {
         return this.withEfficientOps(false);
     }
-    
+
     /**
      * Create a LazyPStackX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyPStackX
      */
-    public static <T> LazyPStackX<T> fromStreamS(Stream<T> stream){
-        return new LazyPStackX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyPStackX<T> fromStreamS(Stream<T> stream) {
+        return new LazyPStackX<T>(
+                                  Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyPStackX that contains the Integers between start and end
      * 
@@ -151,7 +156,7 @@ public static <U, T> LazyPStackX<T> unfold(U seed, Function<? super U, Optional<
     public static <T> LazyPStackX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -164,10 +169,9 @@ public static <T> LazyPStackX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyPStackX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyPStackX
      */
@@ -175,14 +179,13 @@ public static <T> LazyPStackX<T> iterate(long limit, final T seed, final UnaryOp
         return Collectors.toCollection(() -> LazyPStackX.of());
     }
 
-   
-
     /**
      * @return An empty LazyPStackX
      */
     public static <T> LazyPStackX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -203,8 +206,9 @@ public static <T> LazyPStackX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyPStackX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -258,48 +262,60 @@ public static <T> LazyPStackX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyPStackX<T> fromIterable(Reducer<PStack<T>> collector, Iterable<T> it) {
         if (it instanceof LazyPStackX)
             return (LazyPStackX<T>) it;
-       
+
         if (it instanceof PStack)
             return new LazyPStackX<T>(
-                                    (PStack<T>) it, collector);
-        
+                                      (PStack<T>) it, collector);
+
         return new LazyPStackX<T>(
-                                Flux.fromIterable(it),
-                                collector);
-    }
-    private LazyPStackX(PStack<T> list,Reducer<PStack<T>> collector){
-        this.efficientOps=true;
-        this.lazy = new PersistentLazyCollection<T,PStack<T>>(list,null,collector);
-        this.collector=  collector;
-    }
-    private LazyPStackX(boolean efficientOps,PStack<T> list,Reducer<PStack<T>> collector){
-        this.efficientOps=efficientOps;
-        this.lazy = new PersistentLazyCollection<T,PStack<T>>(list,null,collector);
-        this.collector=  collector;
-    }
-    
-    private LazyPStackX(PStack<T> list){
-        this.efficientOps=true;
+                                  Flux.fromIterable(it), collector);
+    }
+
+    private LazyPStackX(PStack<T> list, Reducer<PStack<T>> collector) {
+        this.efficientOps = true;
+        this.lazy = new PersistentLazyCollection<T, PStack<T>>(
+                                                               list, null, collector);
+        this.collector = collector;
+    }
+
+    private LazyPStackX(boolean efficientOps, PStack<T> list, Reducer<PStack<T>> collector) {
+        this.efficientOps = efficientOps;
+        this.lazy = new PersistentLazyCollection<T, PStack<T>>(
+                                                               list, null, collector);
+        this.collector = collector;
+    }
+
+    private LazyPStackX(PStack<T> list) {
+        this.efficientOps = true;
         this.collector = Reducers.toPStack();
-        this.lazy = new PersistentLazyCollection<T,PStack<T>>(list,null,Reducers.toPStack());
+        this.lazy = new PersistentLazyCollection<T, PStack<T>>(
+                                                               list, null, Reducers.toPStack());
     }
-    private LazyPStackX(Flux<T> stream,Reducer<PStack<T>> collector){
-        this.efficientOps=true;
+
+    private LazyPStackX(Flux<T> stream, Reducer<PStack<T>> collector) {
+        this.efficientOps = true;
         this.collector = collector;
-        this.lazy = new PersistentLazyCollection<>(null,stream,Reducers.toPStack());
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, Reducers.toPStack());
     }
-    private LazyPStackX(Flux<T> stream){
-        this.efficientOps=true;
+
+    private LazyPStackX(Flux<T> stream) {
+        this.efficientOps = true;
         this.collector = Reducers.toPStack();
-        this.lazy = new PersistentLazyCollection<>(null,stream,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, collector);
     }
-    private LazyPStackX(){
-        this.efficientOps=true;
+
+    private LazyPStackX() {
+        this.efficientOps = true;
         this.collector = Reducers.toPStack();
-        this.lazy = new PersistentLazyCollection<>((PStack)this.collector.zero(),null,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   (PStack) this.collector.zero(), null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -307,7 +323,9 @@ public void forEach(Consumer<? super T> action) {
         getStack().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -315,7 +333,9 @@ public Iterator<T> iterator() {
         return getStack().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -323,7 +343,9 @@ public int size() {
         return getStack().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -331,7 +353,9 @@ public boolean contains(Object e) {
         return getStack().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -339,9 +363,9 @@ public boolean equals(Object o) {
         return getStack().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -349,7 +373,9 @@ public boolean isEmpty() {
         return getStack().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -357,7 +383,9 @@ public int hashCode() {
         return getStack().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -365,7 +393,9 @@ public Object[] toArray() {
         return getStack().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -373,7 +403,9 @@ public boolean removeAll(Collection<?> c) {
         return getStack().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -381,7 +413,9 @@ public <T> T[] toArray(T[] a) {
         return getStack().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -389,7 +423,9 @@ public boolean add(T e) {
         return getStack().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -397,7 +433,9 @@ public boolean remove(Object o) {
         return getStack().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -405,7 +443,9 @@ public boolean containsAll(Collection<?> c) {
         return getStack().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -413,7 +453,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getStack().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -421,7 +463,9 @@ public boolean retainAll(Collection<?> c) {
         return getStack().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -429,8 +473,9 @@ public void clear() {
         getStack().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -438,7 +483,9 @@ public String toString() {
         return getStack().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -446,928 +493,1223 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#addAll(int, java.util.Collection)
      */
     @Override
     public boolean addAll(int index, Collection<? extends T> c) {
         return getStack().addAll(index, c);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#replaceAll(java.util.function.UnaryOperator)
      */
     @Override
     public void replaceAll(UnaryOperator<T> operator) {
         getStack().replaceAll(operator);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getStack().removeIf(filter);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#sort(java.util.Comparator)
      */
     @Override
-    public  void sort(Comparator<? super T> c) {
+    public void sort(Comparator<? super T> c) {
         getStack().sort(c);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#get(int)
      */
     @Override
     public T get(int index) {
         return getStack().get(index);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#set(int, java.lang.Object)
      */
     @Override
     public T set(int index, T element) {
         return getStack().set(index, element);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#add(int, java.lang.Object)
      */
     @Override
     public void add(int index, T element) {
         getStack().add(index, element);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#remove(int)
      */
     @Override
     public T remove(int index) {
         return getStack().remove(index);
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getStack().parallelStream();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#indexOf(java.lang.Object)
      */
     @Override
     public int indexOf(Object o) {
-        // return stream().zipWithIndex().filter(t->Objects.equals(t.v1,o)).findFirst().get().v2.intValue();
+        // return
+        // stream().zipWithIndex().filter(t->Objects.equals(t.v1,o)).findFirst().get().v2.intValue();
         return getStack().indexOf(o);
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#lastIndexOf(java.lang.Object)
      */
     @Override
     public int lastIndexOf(Object o) {
         return getStack().lastIndexOf(o);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#listIterator()
      */
     @Override
     public ListIterator<T> listIterator() {
         return getStack().listIterator();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#listIterator(int)
      */
     @Override
     public ListIterator<T> listIterator(int index) {
         return getStack().listIterator(index);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#subList(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#subList(int,
+     * int)
      */
     @Override
     public LazyPStackX<T> subList(int fromIndex, int toIndex) {
-        return new LazyPStackX<T>(getStack().subList(fromIndex, toIndex),getCollector());
+        return new LazyPStackX<T>(
+                                  getStack().subList(fromIndex, toIndex), getCollector());
     }
-  
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getStack().spliterator();
     }
-   
+
     /**
      * @return PStack
      */
     private PStack<T> getStack() {
         return lazy.get();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyPStackX<X> stream(Flux<X> stream){
-        return new LazyPStackX<X>(stream);
+    public <X> LazyPStackX<X> stream(Flux<X> stream) {
+        return new LazyPStackX<X>(
+                                  stream);
     }
-   
-    
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flux()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flux()
      */
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combine(java.util.function.BiPredicate,
+     * java.util.function.BinaryOperator)
      */
     @Override
     public LazyPStackX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyPStackX<T>)super.combine(predicate, op);
+
+        return (LazyPStackX<T>) super.combine(predicate, op);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#reverse()
      */
     @Override
     public LazyPStackX<T> reverse() {
-       
-        return(LazyPStackX<T>)super.reverse();
+
+        return (LazyPStackX<T>) super.reverse();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filter(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyPStackX<T>)super.filter(pred);
+
+        return (LazyPStackX<T>) super.filter(pred);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#map(java.util.function.Function)
      */
     @Override
     public <R> LazyPStackX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyPStackX<R>)super.map(mapper);
+
+        return (LazyPStackX<R>) super.map(mapper);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flatMap(java.util.function.Function)
      */
     @Override
     public <R> LazyPStackX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyPStackX<R>)super.flatMap(mapper);
+        return (LazyPStackX<R>) super.flatMap(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limit(long)
      */
     @Override
     public LazyPStackX<T> limit(long num) {
-       return (LazyPStackX<T>)super.limit(num);
+        return (LazyPStackX<T>) super.limit(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skip(long)
      */
     @Override
     public LazyPStackX<T> skip(long num) {
-       return (LazyPStackX<T>)super.skip(num);
+        return (LazyPStackX<T>) super.skip(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeRight(int)
      */
     @Override
     public LazyPStackX<T> takeRight(int num) {
-       return (LazyPStackX<T>)super.takeRight(num);
+        return (LazyPStackX<T>) super.takeRight(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropRight(int)
      */
     @Override
     public LazyPStackX<T> dropRight(int num) {
-       return (LazyPStackX<T>)super.dropRight(num);
+        return (LazyPStackX<T>) super.dropRight(num);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyPStackX<T>)super.takeWhile(p);
+        return (LazyPStackX<T>) super.takeWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyPStackX<T>)super.dropWhile(p);
+        return (LazyPStackX<T>) super.dropWhile(p);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyPStackX<T>)super.takeUntil(p);
+        return (LazyPStackX<T>) super.takeUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyPStackX<T>)super.dropUntil(p);
+        return (LazyPStackX<T>) super.dropUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#trampoline(java.util.function.Function)
      */
     @Override
     public <R> LazyPStackX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyPStackX<R>)super.trampoline(mapper);
+        return (LazyPStackX<R>) super.trampoline(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#slice(long, long)
      */
     @Override
     public LazyPStackX<T> slice(long from, long to) {
-       return (LazyPStackX<T>)super.slice(from, to);
+        return (LazyPStackX<T>) super.slice(from, to);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int)
      */
     @Override
     public LazyPStackX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyPStackX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyPStackX<ListX<T>>) super.grouped(groupSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function,
+     * java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyPStackX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyPStackX)super.grouped(classifier, downstream);
+
+        return (LazyPStackX) super.grouped(classifier, downstream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function)
      */
     @Override
     public <K> LazyPStackX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyPStackX)super.grouped(classifier);
+
+        return (LazyPStackX) super.grouped(classifier);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable)
      */
     @Override
     public <U> LazyPStackX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyPStackX)super.zip(other);
+
+        return (LazyPStackX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPStackX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyPStackX<R>)super.zip(other, zipper);
+    public <U, R> LazyPStackX<R> zip(Iterable<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPStackX<R>) super.zip(other, zipper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int)
      */
     @Override
     public LazyPStackX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyPStackX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyPStackX<ListX<T>>) super.sliding(windowSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int, int)
      */
     @Override
     public LazyPStackX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyPStackX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyPStackX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPStackX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyPStackX<T>)super.scanLeft(monoid);
+
+        return (LazyPStackX<T>) super.scanLeft(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPStackX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyPStackX<U>) super.scanLeft(seed, function);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPStackX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyPStackX<T>)super.scanRight(monoid);
+
+        return (LazyPStackX<T>) super.scanRight(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPStackX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyPStackX<U>)super.scanRight(identity, combiner);
+
+        return (LazyPStackX<U>) super.scanRight(identity, combiner);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyPStackX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyPStackX<T>)super.sorted(function);
+
+        return (LazyPStackX<T>) super.sorted(function);
     }
-    
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusLazy(java.lang.Object)
      */
     @Override
     public LazyPStackX<T> plusLazy(T e) {
-       
-        return (LazyPStackX<T>)super.plusLazy(e);
+
+        return (LazyPStackX<T>) super.plusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPStackX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyPStackX<T>)super.plusAllLazy(list);
+
+        return (LazyPStackX<T>) super.plusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusLazy(java.lang.Object)
      */
     @Override
     public LazyPStackX<T> minusLazy(Object e) {
-       
-        return (LazyPStackX<T>)super.minusLazy(e);
+
+        return (LazyPStackX<T>) super.minusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPStackX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyPStackX<T>)super.minusAllLazy(list);
+
+        return (LazyPStackX<T>) super.minusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(int)
      */
     @Override
     public LazyPStackX<T> cycle(int times) {
-       
-        return (LazyPStackX<T>)super.cycle(times);
+
+        return (LazyPStackX<T>) super.cycle(times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
      */
     @Override
     public LazyPStackX<T> cycle(Monoid<T> m, int times) {
-       
-        return (LazyPStackX<T>)super.cycle(m, times);
+
+        return (LazyPStackX<T>) super.cycle(m, times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPStackX<T>)super.cycleWhile(predicate);
+
+        return (LazyPStackX<T>) super.cycleWhile(predicate);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPStackX<T>)super.cycleUntil(predicate);
+
+        return (LazyPStackX<T>) super.cycleUntil(predicate);
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
      */
     @Override
     public <U> LazyPStackX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyPStackX)super.zip(other);
+
+        return (LazyPStackX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip3(java.util.stream.Stream,
+     * java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyPStackX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyPStackX)super.zip3(second, third);
+
+        return (LazyPStackX) super.zip3(second, third);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip4(java.util.stream.Stream,
+     * java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazyPStackX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazyPStackX)super.zip4(second, third, fourth);
+
+        return (LazyPStackX) super.zip4(second, third, fourth);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zipWithIndex()
      */
     @Override
     public LazyPStackX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyPStackX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyPStackX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#distinct()
      */
     @Override
     public LazyPStackX<T> distinct() {
-       
-        return (LazyPStackX<T>)super.distinct();
+
+        return (LazyPStackX<T>) super.distinct();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted()
      */
     @Override
     public LazyPStackX<T> sorted() {
-       
-        return (LazyPStackX<T>)super.sorted();
+
+        return (LazyPStackX<T>) super.sorted();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.Comparator)
      */
     @Override
     public LazyPStackX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyPStackX<T>)super.sorted(c);
+
+        return (LazyPStackX<T>) super.sorted(c);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyPStackX<T>)super.skipWhile(p);
+
+        return (LazyPStackX<T>) super.skipWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyPStackX<T>)super.skipUntil(p);
+
+        return (LazyPStackX<T>) super.skipUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyPStackX<T>)super.limitWhile(p);
+
+        return (LazyPStackX<T>) super.limitWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyPStackX<T>)super.limitUntil(p);
+
+        return (LazyPStackX<T>) super.limitUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#intersperse(java.lang.Object)
      */
     @Override
     public LazyPStackX<T> intersperse(T value) {
-       
-        return (LazyPStackX<T>)super.intersperse(value);
+
+        return (LazyPStackX<T>) super.intersperse(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle()
      */
     @Override
     public LazyPStackX<T> shuffle() {
-       
-        return (LazyPStackX<T>)super.shuffle();
+
+        return (LazyPStackX<T>) super.shuffle();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipLast(int)
      */
     @Override
     public LazyPStackX<T> skipLast(int num) {
-       
-        return (LazyPStackX<T>)super.skipLast(num);
+
+        return (LazyPStackX<T>) super.skipLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitLast(int)
      */
     @Override
     public LazyPStackX<T> limitLast(int num) {
-       
-        return (LazyPStackX<T>)super.limitLast(num);
+
+        return (LazyPStackX<T>) super.limitLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmpty(java.lang.Object)
      */
     @Override
     public LazyPStackX<T> onEmpty(T value) {
-       
-        return (LazyPStackX<T>)super.onEmpty(value);
+
+        return (LazyPStackX<T>) super.onEmpty(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
      */
     @Override
     public LazyPStackX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyPStackX<T>)super.onEmptyGet(supplier);
+
+        return (LazyPStackX<T>) super.onEmptyGet(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyPStackX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyPStackX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyPStackX<T>) super.onEmptyThrow(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle(java.util.Random)
      */
     @Override
     public LazyPStackX<T> shuffle(Random random) {
-       
-        return (LazyPStackX<T>)super.shuffle(random);
+
+        return (LazyPStackX<T>) super.shuffle(random);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#ofType(java.lang.Class)
      */
     @Override
     public <U> LazyPStackX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyPStackX<U>)super.ofType(type);
+
+        return (LazyPStackX<U>) super.ofType(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyPStackX<T>)super.filterNot(fn);
+
+        return (LazyPStackX<T>) super.filterNot(fn);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#notNull()
      */
     @Override
     public LazyPStackX<T> notNull() {
-       
-        return (LazyPStackX<T>)super.notNull();
+
+        return (LazyPStackX<T>) super.notNull();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
      */
     @Override
     public LazyPStackX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyPStackX<T>)(super.removeAll(stream));
+
+        return (LazyPStackX<T>) (super.removeAll(stream));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPStackX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyPStackX<T>)super.removeAll(stream);
+
+        return (LazyPStackX<T>) super.removeAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Iterable)
      */
     @Override
     public LazyPStackX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyPStackX<T>)super.removeAll(it);
+
+        return (LazyPStackX<T>) super.removeAll(it);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Object[])
      */
     @Override
     public LazyPStackX<T> removeAll(T... values) {
-       
-        return (LazyPStackX<T>)super.removeAll(values);
+
+        return (LazyPStackX<T>) super.removeAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Iterable)
      */
     @Override
     public LazyPStackX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyPStackX<T>)super.retainAll(it);
+
+        return (LazyPStackX<T>) super.retainAll(it);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
      */
     @Override
     public LazyPStackX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyPStackX<T>)super.retainAll(stream);
+
+        return (LazyPStackX<T>) super.retainAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPStackX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyPStackX<T>)super.retainAll(stream);
+
+        return (LazyPStackX<T>) super.retainAll(stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Object[])
      */
     @Override
     public LazyPStackX<T> retainAll(T... values) {
-       
-        return (LazyPStackX<T>)super.retainAll(values);
+
+        return (LazyPStackX<T>) super.retainAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cast(java.lang.Class)
      */
     @Override
     public <U> LazyPStackX<U> cast(Class<? extends U> type) {
-       
-        return (LazyPStackX<U>)super.cast(type);
+
+        return (LazyPStackX<U>) super.cast(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
     public <R> LazyPStackX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyPStackX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyPStackX<R>) super.patternMatch(case1, otherwise);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#permutations()
      */
     @Override
     public LazyPStackX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyPStackX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyPStackX<ReactiveSeq<T>>) super.permutations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations(int)
      */
     @Override
     public LazyPStackX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyPStackX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyPStackX<ReactiveSeq<T>>) super.combinations(size);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations()
      */
     @Override
     public LazyPStackX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyPStackX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyPStackX<ReactiveSeq<T>>) super.combinations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPStackX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyPStackX<C>)super.grouped(size, supplier);
+
+        return (LazyPStackX<C>) super.grouped(size, supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPStackX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyPStackX<ListX<T>>) super.groupedUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPStackX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPStackX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyPStackX<ListX<T>>) super.groupedWhile(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPStackX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPStackX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyPStackX<C>) super.groupedWhile(predicate, factory);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPStackX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPStackX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyPStackX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** PStackX methods **/
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int, java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int,
+     * java.lang.Object)
      */
-    public LazyPStackX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyPStackX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    
- 
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyPStackX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyPStackX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyPStackX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyPStackX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyPStackX)super.peek(c);
+
+        return (LazyPStackX) super.peek(c);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPStackX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyPStackX<R>)super.zip(other, zipper);
+    public <U, R> LazyPStackX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPStackX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPStackX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyPStackX<R>)super.zip(other, zipper);
+    public <U, R> LazyPStackX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPStackX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyPStackX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyPStackX)super.zip(other);
+
+        return (LazyPStackX) super.zip(other);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyPStackX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyPStackX<R>)super.zip(fn, publisher);
+
+        return (LazyPStackX<R>) super.zip(fn, publisher);
     }
- 
-   
-  
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyPStackX<T> onEmptySwitch(Supplier<? extends PStack<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
-       
-    }
-    
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
 
-  
+    }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PStack#subList(int)
      */
     @Override
     public LazyPStackX<T> subList(int start) {
         return stream(flux().take(start));
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(
+     * Collection)
      */
     @Override
     public <R> LazyPStackX<R> unit(Collection<R> col) {
@@ -1375,14 +1717,14 @@ public <R> LazyPStackX<R> unit(Collection<R> col) {
             return fromIterable(col);
         return fromIterable(col).efficientOpsOff();
     }
-    
+
     @Override
     public <R> LazyPStackX<R> unit(R value) {
         return singleton(value);
     }
 
     @Override
-    public<R> LazyPStackX<R> unitIterator(Iterator<R> it) {
+    public <R> LazyPStackX<R> unitIterator(Iterator<R> it) {
         return fromIterable(() -> it);
     }
 
@@ -1391,7 +1733,7 @@ public <R> LazyPStackX<R> emptyUnit() {
         if (isEfficientOps())
             return empty();
         return LazyPStackX.<R> empty()
-                      .efficientOpsOff();
+                          .efficientOpsOff();
     }
 
     /**
@@ -1413,12 +1755,14 @@ public ReactiveSeq<T> stream() {
 
         return ReactiveSeq.fromIterable(this);
     }
+
     @Override
     public <X> LazyPStackX<X> from(Collection<X> col) {
         if (isEfficientOps())
             return fromIterable(col);
         return fromIterable(col).efficientOpsOff();
     }
+
     @Override
     public <T> Reducer<PStack<T>> monoid() {
         if (isEfficientOps())
@@ -1426,52 +1770,75 @@ public <T> Reducer<PStack<T>> monoid() {
         return Reducers.toPStack();
 
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plus(java.lang.Object)
      */
     public LazyPStackX<T> plus(T e) {
-        return new LazyPStackX<T>(efficientOps,getStack().plus(e),this.collector);
+        return new LazyPStackX<T>(
+                                  efficientOps, getStack().plus(e), this.collector);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PStack#plus(int, java.lang.Object)
      */
     public LazyPStackX<T> plus(int i, T e) {
-        return new LazyPStackX<T>(efficientOps,getStack().plus(i,e),this.collector);
+        return new LazyPStackX<T>(
+                                  efficientOps, getStack().plus(i, e), this.collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#minus(java.lang.Object)
      */
-    public  LazyPStackX<T> minus(Object e) {
-        return new LazyPStackX<T>(efficientOps,getStack().minus(e),this.collector);
+    public LazyPStackX<T> minus(Object e) {
+        return new LazyPStackX<T>(
+                                  efficientOps, getStack().minus(e), this.collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plusAll(java.util.Collection)
      */
-    public  LazyPStackX<T> plusAll(Collection<? extends T> list) {
-        return new LazyPStackX<T>(efficientOps,getStack().plusAll(list),this.collector);
+    public LazyPStackX<T> plusAll(Collection<? extends T> list) {
+        return new LazyPStackX<T>(
+                                  efficientOps, getStack().plusAll(list), this.collector);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PStack#plusAll(int, java.util.Collection)
      */
     public LazyPStackX<T> plusAll(int i, Collection<? extends T> list) {
-        return new LazyPStackX<T>(efficientOps,getStack().plusAll(i,list),this.collector);
+        return new LazyPStackX<T>(
+                                  efficientOps, getStack().plusAll(i, list), this.collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#minusAll(java.util.Collection)
      */
     public LazyPStackX<T> minusAll(Collection<?> list) {
-        return new LazyPStackX<T>(efficientOps,getStack().minusAll(list),this.collector);
+        return new LazyPStackX<T>(
+                                  efficientOps, getStack().minusAll(list), this.collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PStack#minus(int)
      */
     public LazyPStackX<T> minus(int i) {
-        return new LazyPStackX<T>(efficientOps,getStack().minus(i),this.collector);
+        return new LazyPStackX<T>(
+                                  efficientOps, getStack().minus(i), this.collector);
     }
 
-   
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPVectorX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPVectorX.java
index 1c54b1a5..b745fdc5 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPVectorX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/persistent/LazyPVectorX.java
@@ -45,6 +45,7 @@
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended List type {@see java.util.List}. 
  * This makes use of PVector (@see org.pcollections.PStack) from PCollectons. PVector is a persistent analogue of  the 
@@ -73,24 +74,23 @@
  *
  * @param <T> the type of elements held in this collection
  */
-@AllArgsConstructor(access=AccessLevel.PRIVATE)
-public class LazyPVectorX<T> extends AbstractFluentCollectionX<T> implements PVectorX<T> {
-    private final  LazyFluentCollection<T,PVector<T>> lazy;
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class LazyPVectorX<T> extends AbstractFluentCollectionX<T>implements PVectorX<T> {
+    private final LazyFluentCollection<T, PVector<T>> lazy;
     @Getter
     private final Reducer<PVector<T>> collector;
-   
 
-  
-    
     /**
      * Create a LazyPStackX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyPStackX
      */
-    public static <T> LazyPVectorX<T> fromStreamS(Stream<T> stream){
-        return new LazyPVectorX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyPVectorX<T> fromStreamS(Stream<T> stream) {
+        return new LazyPVectorX<T>(
+                                   Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyPStackX that contains the Integers between start and end
      * 
@@ -146,7 +146,7 @@ public static <U, T> LazyPVectorX<T> unfold(U seed, Function<? super U, Optional
     public static <T> LazyPVectorX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -159,10 +159,9 @@ public static <T> LazyPVectorX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyPVectorX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyPStackX
      */
@@ -170,14 +169,13 @@ public static <T> LazyPVectorX<T> iterate(long limit, final T seed, final UnaryO
         return Collectors.toCollection(() -> LazyPVectorX.of());
     }
 
-   
-
     /**
      * @return An empty LazyPStackX
      */
     public static <T> LazyPVectorX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -198,8 +196,9 @@ public static <T> LazyPVectorX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyPVectorX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -253,42 +252,54 @@ public static <T> LazyPVectorX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyPVectorX<T> fromIterable(Reducer<PVector<T>> collector, Iterable<T> it) {
         if (it instanceof LazyPVectorX)
             return (LazyPVectorX<T>) it;
-       
+
         if (it instanceof PVector)
             return new LazyPVectorX<T>(
-                                    (PVector<T>) it, collector);
-        
+                                       (PVector<T>) it, collector);
+
         return new LazyPVectorX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                   Flux.fromIterable(it), collector);
     }
-    private LazyPVectorX(PVector<T> list,Reducer<PVector<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PVector<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPVectorX(PVector<T> list, Reducer<PVector<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PVector<T>>(
+                                                                list, null, collector);
+        this.collector = collector;
     }
-    private LazyPVectorX(boolean efficientOps,PVector<T> list,Reducer<PVector<T>> collector){
-        this.lazy = new PersistentLazyCollection<T,PVector<T>>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyPVectorX(boolean efficientOps, PVector<T> list, Reducer<PVector<T>> collector) {
+        this.lazy = new PersistentLazyCollection<T, PVector<T>>(
+                                                                list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyPVectorX(PVector<T> list){
+
+    private LazyPVectorX(PVector<T> list) {
         this.collector = Reducers.toPVector();
-        this.lazy = new PersistentLazyCollection<T,PVector<T>>(list,null,Reducers.toPVector());
+        this.lazy = new PersistentLazyCollection<T, PVector<T>>(
+                                                                list, null, Reducers.toPVector());
     }
-    private LazyPVectorX(Flux<T> stream,Reducer<PVector<T>> collector){
+
+    private LazyPVectorX(Flux<T> stream, Reducer<PVector<T>> collector) {
         this.collector = collector;
-        this.lazy = new PersistentLazyCollection<>(null,stream,Reducers.toPVector());
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, Reducers.toPVector());
     }
-    private LazyPVectorX(Flux<T> stream){
+
+    private LazyPVectorX(Flux<T> stream) {
         this.collector = Reducers.toPVector();
-        this.lazy = new PersistentLazyCollection<>(null,stream,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   null, stream, collector);
     }
-    private LazyPVectorX(){
+
+    private LazyPVectorX() {
         this.collector = Reducers.toPVector();
-        this.lazy = new PersistentLazyCollection<>((PVector)this.collector.zero(),null,collector);
+        this.lazy = new PersistentLazyCollection<>(
+                                                   (PVector) this.collector.zero(), null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -296,7 +307,9 @@ public void forEach(Consumer<? super T> action) {
         getVector().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -304,7 +317,9 @@ public Iterator<T> iterator() {
         return getVector().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -312,7 +327,9 @@ public int size() {
         return getVector().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -320,7 +337,9 @@ public boolean contains(Object e) {
         return getVector().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -328,9 +347,9 @@ public boolean equals(Object o) {
         return getVector().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -338,7 +357,9 @@ public boolean isEmpty() {
         return getVector().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -346,7 +367,9 @@ public int hashCode() {
         return getVector().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -354,7 +377,9 @@ public Object[] toArray() {
         return getVector().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -362,7 +387,9 @@ public boolean removeAll(Collection<?> c) {
         return getVector().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -370,7 +397,9 @@ public <T> T[] toArray(T[] a) {
         return getVector().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -378,7 +407,9 @@ public boolean add(T e) {
         return getVector().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -386,7 +417,9 @@ public boolean remove(Object o) {
         return getVector().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -394,7 +427,9 @@ public boolean containsAll(Collection<?> c) {
         return getVector().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -402,7 +437,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getVector().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -410,7 +447,9 @@ public boolean retainAll(Collection<?> c) {
         return getVector().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -418,8 +457,9 @@ public void clear() {
         getVector().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -427,7 +467,9 @@ public String toString() {
         return getVector().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -435,926 +477,1223 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#addAll(int, java.util.Collection)
      */
     @Override
     public boolean addAll(int index, Collection<? extends T> c) {
         return getVector().addAll(index, c);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#replaceAll(java.util.function.UnaryOperator)
      */
     @Override
     public void replaceAll(UnaryOperator<T> operator) {
         getVector().replaceAll(operator);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getVector().removeIf(filter);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#sort(java.util.Comparator)
      */
     @Override
-    public  void sort(Comparator<? super T> c) {
+    public void sort(Comparator<? super T> c) {
         getVector().sort(c);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#get(int)
      */
     @Override
     public T get(int index) {
         return getVector().get(index);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#set(int, java.lang.Object)
      */
     @Override
     public T set(int index, T element) {
         return getVector().set(index, element);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#add(int, java.lang.Object)
      */
     @Override
     public void add(int index, T element) {
         getVector().add(index, element);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#remove(int)
      */
     @Override
     public T remove(int index) {
         return getVector().remove(index);
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getVector().parallelStream();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#indexOf(java.lang.Object)
      */
     @Override
     public int indexOf(Object o) {
-        // return stream().zipWithIndex().filter(t->Objects.equals(t.v1,o)).findFirst().get().v2.intValue();
+        // return
+        // stream().zipWithIndex().filter(t->Objects.equals(t.v1,o)).findFirst().get().v2.intValue();
         return getVector().indexOf(o);
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#lastIndexOf(java.lang.Object)
      */
     @Override
     public int lastIndexOf(Object o) {
         return getVector().lastIndexOf(o);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#listIterator()
      */
     @Override
     public ListIterator<T> listIterator() {
         return getVector().listIterator();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#listIterator(int)
      */
     @Override
     public ListIterator<T> listIterator(int index) {
         return getVector().listIterator(index);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#subList(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#subList(int,
+     * int)
      */
     @Override
     public LazyPVectorX<T> subList(int fromIndex, int toIndex) {
-        return new LazyPVectorX<T>(getVector().subList(fromIndex, toIndex),getCollector());
+        return new LazyPVectorX<T>(
+                                   getVector().subList(fromIndex, toIndex), getCollector());
     }
-  
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getVector().spliterator();
     }
-   
+
     /**
      * @return PStack
      */
     private PVector<T> getVector() {
         return lazy.get();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyPVectorX<X> stream(Flux<X> stream){
-        return new LazyPVectorX<X>(stream);
+    public <X> LazyPVectorX<X> stream(Flux<X> stream) {
+        return new LazyPVectorX<X>(
+                                   stream);
     }
-   
-    
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flux()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flux()
      */
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combine(java.util.function.BiPredicate,
+     * java.util.function.BinaryOperator)
      */
     @Override
     public LazyPVectorX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyPVectorX<T>)super.combine(predicate, op);
+
+        return (LazyPVectorX<T>) super.combine(predicate, op);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#reverse()
      */
     @Override
     public LazyPVectorX<T> reverse() {
-       
-        return(LazyPVectorX<T>)super.reverse();
+
+        return (LazyPVectorX<T>) super.reverse();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filter(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyPVectorX<T>)super.filter(pred);
+
+        return (LazyPVectorX<T>) super.filter(pred);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#map(java.util.function.Function)
      */
     @Override
     public <R> LazyPVectorX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyPVectorX<R>)super.map(mapper);
+
+        return (LazyPVectorX<R>) super.map(mapper);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#flatMap(java.util.function.Function)
      */
     @Override
     public <R> LazyPVectorX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyPVectorX<R>)super.flatMap(mapper);
+        return (LazyPVectorX<R>) super.flatMap(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limit(long)
      */
     @Override
     public LazyPVectorX<T> limit(long num) {
-       return (LazyPVectorX<T>)super.limit(num);
+        return (LazyPVectorX<T>) super.limit(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skip(long)
      */
     @Override
     public LazyPVectorX<T> skip(long num) {
-       return (LazyPVectorX<T>)super.skip(num);
+        return (LazyPVectorX<T>) super.skip(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeRight(int)
      */
     @Override
     public LazyPVectorX<T> takeRight(int num) {
-       return (LazyPVectorX<T>)super.takeRight(num);
+        return (LazyPVectorX<T>) super.takeRight(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropRight(int)
      */
     @Override
     public LazyPVectorX<T> dropRight(int num) {
-       return (LazyPVectorX<T>)super.dropRight(num);
+        return (LazyPVectorX<T>) super.dropRight(num);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyPVectorX<T>)super.takeWhile(p);
+        return (LazyPVectorX<T>) super.takeWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyPVectorX<T>)super.dropWhile(p);
+        return (LazyPVectorX<T>) super.dropWhile(p);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#takeUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyPVectorX<T>)super.takeUntil(p);
+        return (LazyPVectorX<T>) super.takeUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#dropUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyPVectorX<T>)super.dropUntil(p);
+        return (LazyPVectorX<T>) super.dropUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#trampoline(java.util.function.Function)
      */
     @Override
     public <R> LazyPVectorX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyPVectorX<R>)super.trampoline(mapper);
+        return (LazyPVectorX<R>) super.trampoline(mapper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#slice(long, long)
      */
     @Override
     public LazyPVectorX<T> slice(long from, long to) {
-       return (LazyPVectorX<T>)super.slice(from, to);
+        return (LazyPVectorX<T>) super.slice(from, to);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int)
      */
     @Override
     public LazyPVectorX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyPVectorX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyPVectorX<ListX<T>>) super.grouped(groupSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function,
+     * java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyPVectorX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyPVectorX)super.grouped(classifier, downstream);
+
+        return (LazyPVectorX) super.grouped(classifier, downstream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function)
      */
     @Override
     public <K> LazyPVectorX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyPVectorX)super.grouped(classifier);
+
+        return (LazyPVectorX) super.grouped(classifier);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable)
      */
     @Override
     public <U> LazyPVectorX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyPVectorX)super.zip(other);
+
+        return (LazyPVectorX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.lang.Iterable,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPVectorX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyPVectorX<R>)super.zip(other, zipper);
+    public <U, R> LazyPVectorX<R> zip(Iterable<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPVectorX<R>) super.zip(other, zipper);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int)
      */
     @Override
     public LazyPVectorX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyPVectorX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyPVectorX<ListX<T>>) super.sliding(windowSize);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sliding(int, int)
      */
     @Override
     public LazyPVectorX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyPVectorX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyPVectorX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPVectorX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyPVectorX<T>)super.scanLeft(monoid);
+
+        return (LazyPVectorX<T>) super.scanLeft(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanLeft(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPVectorX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyPVectorX<U>) super.scanLeft(seed, function);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(com.aol.cyclops.Monoid)
      */
     @Override
     public LazyPVectorX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyPVectorX<T>)super.scanRight(monoid);
+
+        return (LazyPVectorX<T>) super.scanRight(monoid);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#scanRight(java.lang.Object,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U> LazyPVectorX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyPVectorX<U>)super.scanRight(identity, combiner);
+
+        return (LazyPVectorX<U>) super.scanRight(identity, combiner);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyPVectorX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyPVectorX<T>)super.sorted(function);
+
+        return (LazyPVectorX<T>) super.sorted(function);
     }
-    
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusLazy(java.lang.Object)
      */
     @Override
     public LazyPVectorX<T> plusLazy(T e) {
-       
-        return (LazyPVectorX<T>)super.plusLazy(e);
+
+        return (LazyPVectorX<T>) super.plusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#plusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPVectorX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyPVectorX<T>)super.plusAllLazy(list);
+
+        return (LazyPVectorX<T>) super.plusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusLazy(java.lang.Object)
      */
     @Override
     public LazyPVectorX<T> minusLazy(Object e) {
-       
-        return (LazyPVectorX<T>)super.minusLazy(e);
+
+        return (LazyPVectorX<T>) super.minusLazy(e);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#minusAllLazy(java.util.Collection)
      */
     @Override
     public LazyPVectorX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyPVectorX<T>)super.minusAllLazy(list);
+
+        return (LazyPVectorX<T>) super.minusAllLazy(list);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(int)
      */
     @Override
     public LazyPVectorX<T> cycle(int times) {
-       
-        return (LazyPVectorX<T>)super.cycle(times);
+
+        return (LazyPVectorX<T>) super.cycle(times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycle(com.aol.cyclops.Monoid, int)
      */
     @Override
     public LazyPVectorX<T> cycle(Monoid<T> m, int times) {
-       
-        return (LazyPVectorX<T>)super.cycle(m, times);
+
+        return (LazyPVectorX<T>) super.cycle(m, times);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPVectorX<T>)super.cycleWhile(predicate);
+
+        return (LazyPVectorX<T>) super.cycleWhile(predicate);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cycleUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPVectorX<T>)super.cycleUntil(predicate);
+
+        return (LazyPVectorX<T>) super.cycleUntil(predicate);
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq)
      */
     @Override
     public <U> LazyPVectorX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyPVectorX)super.zip(other);
+
+        return (LazyPVectorX) super.zip(other);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip3(java.util.stream.Stream,
+     * java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyPVectorX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyPVectorX)super.zip3(second, third);
+
+        return (LazyPVectorX) super.zip3(second, third);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip4(java.util.stream.Stream,
+     * java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
-    public <T2, T3, T4> LazyPVectorX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
-            Stream<? extends T4> fourth) {
-       
-        return (LazyPVectorX)super.zip4(second, third, fourth);
+    public <T2, T3, T4> LazyPVectorX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second,
+            Stream<? extends T3> third, Stream<? extends T4> fourth) {
+
+        return (LazyPVectorX) super.zip4(second, third, fourth);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zipWithIndex()
      */
     @Override
     public LazyPVectorX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyPVectorX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyPVectorX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#distinct()
      */
     @Override
     public LazyPVectorX<T> distinct() {
-       
-        return (LazyPVectorX<T>)super.distinct();
+
+        return (LazyPVectorX<T>) super.distinct();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted()
      */
     @Override
     public LazyPVectorX<T> sorted() {
-       
-        return (LazyPVectorX<T>)super.sorted();
+
+        return (LazyPVectorX<T>) super.sorted();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#sorted(java.util.Comparator)
      */
     @Override
     public LazyPVectorX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyPVectorX<T>)super.sorted(c);
+
+        return (LazyPVectorX<T>) super.sorted(c);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyPVectorX<T>)super.skipWhile(p);
+
+        return (LazyPVectorX<T>) super.skipWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyPVectorX<T>)super.skipUntil(p);
+
+        return (LazyPVectorX<T>) super.skipUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyPVectorX<T>)super.limitWhile(p);
+
+        return (LazyPVectorX<T>) super.limitWhile(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyPVectorX<T>)super.limitUntil(p);
+
+        return (LazyPVectorX<T>) super.limitUntil(p);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#intersperse(java.lang.Object)
      */
     @Override
     public LazyPVectorX<T> intersperse(T value) {
-       
-        return (LazyPVectorX<T>)super.intersperse(value);
+
+        return (LazyPVectorX<T>) super.intersperse(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle()
      */
     @Override
     public LazyPVectorX<T> shuffle() {
-       
-        return (LazyPVectorX<T>)super.shuffle();
+
+        return (LazyPVectorX<T>) super.shuffle();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#skipLast(int)
      */
     @Override
     public LazyPVectorX<T> skipLast(int num) {
-       
-        return (LazyPVectorX<T>)super.skipLast(num);
+
+        return (LazyPVectorX<T>) super.skipLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#limitLast(int)
      */
     @Override
     public LazyPVectorX<T> limitLast(int num) {
-       
-        return (LazyPVectorX<T>)super.limitLast(num);
+
+        return (LazyPVectorX<T>) super.limitLast(num);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmpty(java.lang.Object)
      */
     @Override
     public LazyPVectorX<T> onEmpty(T value) {
-       
-        return (LazyPVectorX<T>)super.onEmpty(value);
+
+        return (LazyPVectorX<T>) super.onEmpty(value);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyGet(java.util.function.Supplier)
      */
     @Override
     public LazyPVectorX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyPVectorX<T>)super.onEmptyGet(supplier);
+
+        return (LazyPVectorX<T>) super.onEmptyGet(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#onEmptyThrow(java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyPVectorX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyPVectorX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyPVectorX<T>) super.onEmptyThrow(supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#shuffle(java.util.Random)
      */
     @Override
     public LazyPVectorX<T> shuffle(Random random) {
-       
-        return (LazyPVectorX<T>)super.shuffle(random);
+
+        return (LazyPVectorX<T>) super.shuffle(random);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#ofType(java.lang.Class)
      */
     @Override
     public <U> LazyPVectorX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyPVectorX<U>)super.ofType(type);
+
+        return (LazyPVectorX<U>) super.ofType(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#filterNot(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyPVectorX<T>)super.filterNot(fn);
+
+        return (LazyPVectorX<T>) super.filterNot(fn);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#notNull()
      */
     @Override
     public LazyPVectorX<T> notNull() {
-       
-        return (LazyPVectorX<T>)super.notNull();
+
+        return (LazyPVectorX<T>) super.notNull();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.util.stream.Stream)
      */
     @Override
     public LazyPVectorX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyPVectorX<T>)(super.removeAll(stream));
+
+        return (LazyPVectorX<T>) (super.removeAll(stream));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPVectorX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyPVectorX<T>)super.removeAll(stream);
+
+        return (LazyPVectorX<T>) super.removeAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Iterable)
      */
     @Override
     public LazyPVectorX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyPVectorX<T>)super.removeAll(it);
+
+        return (LazyPVectorX<T>) super.removeAll(it);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#removeAll(java.lang.Object[])
      */
     @Override
     public LazyPVectorX<T> removeAll(T... values) {
-       
-        return (LazyPVectorX<T>)super.removeAll(values);
+
+        return (LazyPVectorX<T>) super.removeAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Iterable)
      */
     @Override
     public LazyPVectorX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyPVectorX<T>)super.retainAll(it);
+
+        return (LazyPVectorX<T>) super.retainAll(it);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.util.stream.Stream)
      */
     @Override
     public LazyPVectorX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyPVectorX<T>)super.retainAll(stream);
+
+        return (LazyPVectorX<T>) super.retainAll(stream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(org.jooq.lambda.Seq)
      */
     @Override
     public LazyPVectorX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyPVectorX<T>)super.retainAll(stream);
+
+        return (LazyPVectorX<T>) super.retainAll(stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#retainAll(java.lang.Object[])
      */
     @Override
     public LazyPVectorX<T> retainAll(T... values) {
-       
-        return (LazyPVectorX<T>)super.retainAll(values);
+
+        return (LazyPVectorX<T>) super.retainAll(values);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#cast(java.lang.Class)
      */
     @Override
     public <U> LazyPVectorX<U> cast(Class<? extends U> type) {
-       
-        return (LazyPVectorX<U>)super.cast(type);
+
+        return (LazyPVectorX<U>) super.cast(type);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
     public <R> LazyPVectorX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyPVectorX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyPVectorX<R>) super.patternMatch(case1, otherwise);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#permutations()
      */
     @Override
     public LazyPVectorX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyPVectorX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyPVectorX<ReactiveSeq<T>>) super.permutations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations(int)
      */
     @Override
     public LazyPVectorX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyPVectorX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyPVectorX<ReactiveSeq<T>>) super.combinations(size);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations()
      */
     @Override
     public LazyPVectorX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyPVectorX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyPVectorX<ReactiveSeq<T>>) super.combinations();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(int, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPVectorX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyPVectorX<C>)super.grouped(size, supplier);
+
+        return (LazyPVectorX<C>) super.grouped(size, supplier);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyPVectorX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyPVectorX<ListX<T>>) super.groupedUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate)
      */
     @Override
     public LazyPVectorX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyPVectorX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyPVectorX<ListX<T>>) super.groupedWhile(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedWhile(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPVectorX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPVectorX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyPVectorX<C>) super.groupedWhile(predicate, factory);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedUntil(java.util.function.Predicate,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyPVectorX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyPVectorX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyPVectorX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** PStackX methods **/
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int, java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#with(int,
+     * java.lang.Object)
      */
-    public LazyPVectorX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyPVectorX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    
- 
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyPVectorX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyPVectorX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyPVectorX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyPVectorX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyPVectorX)super.peek(c);
+
+        return (LazyPVectorX) super.peek(c);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPVectorX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyPVectorX<R>)super.zip(other, zipper);
+    public <U, R> LazyPVectorX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPVectorX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyPVectorX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyPVectorX<R>)super.zip(other, zipper);
+    public <U, R> LazyPVectorX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyPVectorX<R>) super.zip(other, zipper);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyPVectorX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyPVectorX)super.zip(other);
+
+        return (LazyPVectorX) super.zip(other);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyPVectorX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyPVectorX<R>)super.zip(fn, publisher);
+
+        return (LazyPVectorX<R>) super.zip(fn, publisher);
     }
- 
-   
-  
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyPVectorX<T> onEmptySwitch(Supplier<? extends PVector<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
-       
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
+
     }
-    
 
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#unit(
+     * Collection)
      */
     @Override
     public <R> LazyPVectorX<R> unit(Collection<R> col) {
-       
+
         return fromIterable(col);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
      */
     @Override
@@ -1362,43 +1701,58 @@ public <R> LazyPVectorX<R> unit(R value) {
         return singleton(value);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#unitIterator(java.util.Iterator)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#unitIterator(java.util.Iterator)
      */
     @Override
-    public<R> LazyPVectorX<R> unitIterator(Iterator<R> it) {
+    public <R> LazyPVectorX<R> unitIterator(Iterator<R> it) {
         return fromIterable(() -> it);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PVectorX#emptyUnit()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PVectorX#emptyUnit
+     * ()
      */
     @Override
     public <R> LazyPVectorX<R> emptyUnit() {
-       
+
         return LazyPVectorX.<R> empty();
     }
 
-
-    /* 
+    /*
      * This converted to PVector
      * 
      * (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PVectorX#toPVector()
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PVectorX#toPVector
+     * ()
      */
     public LazyPVectorX<T> toPVector() {
         return this;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyPVectorX<T> plusInOrder(T e) {
         return plus(size(), e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.CollectionX#stream()
      */
     @Override
@@ -1406,68 +1760,99 @@ public ReactiveSeq<T> stream() {
 
         return ReactiveSeq.fromIterable(this);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <X> LazyPVectorX<X> from(Collection<X> col) {
         return fromIterable(col);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PVectorX#monoid()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PVectorX#monoid()
      */
     @Override
     public <T> Reducer<PVector<T>> monoid() {
-       
+
         return Reducers.toPVector();
 
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plus(java.lang.Object)
      */
     public LazyPVectorX<T> plus(T e) {
-        return new LazyPVectorX<T>(getVector().plus(e),this.collector);
+        return new LazyPVectorX<T>(
+                                   getVector().plus(e), this.collector);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PStack#plus(int, java.lang.Object)
      */
     public LazyPVectorX<T> plus(int i, T e) {
-        return new LazyPVectorX<T>(getVector().plus(i,e),this.collector);
+        return new LazyPVectorX<T>(
+                                   getVector().plus(i, e), this.collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#minus(java.lang.Object)
      */
-    public  LazyPVectorX<T> minus(Object e) {
-        return new LazyPVectorX<T>(getVector().minus(e),this.collector);
+    public LazyPVectorX<T> minus(Object e) {
+        return new LazyPVectorX<T>(
+                                   getVector().minus(e), this.collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#plusAll(java.util.Collection)
      */
-    public  LazyPVectorX<T> plusAll(Collection<? extends T> list) {
-        return new LazyPVectorX<T>(getVector().plusAll(list),this.collector);
+    public LazyPVectorX<T> plusAll(Collection<? extends T> list) {
+        return new LazyPVectorX<T>(
+                                   getVector().plusAll(list), this.collector);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PStack#plusAll(int, java.util.Collection)
      */
     public LazyPVectorX<T> plusAll(int i, Collection<? extends T> list) {
-        return new LazyPVectorX<T>(getVector().plusAll(i,list),this.collector);
+        return new LazyPVectorX<T>(
+                                   getVector().plusAll(i, list), this.collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.MapPSet#minusAll(java.util.Collection)
      */
     public LazyPVectorX<T> minusAll(Collection<?> list) {
-        return new LazyPVectorX<T>(getVector().minusAll(list),this.collector);
+        return new LazyPVectorX<T>(
+                                   getVector().minusAll(list), this.collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.pcollections.PStack#minus(int)
      */
     public LazyPVectorX<T> minus(int i) {
-        return new LazyPVectorX<T>(getVector().minus(i),this.collector);
+        return new LazyPVectorX<T>(
+                                   getVector().minus(i), this.collector);
     }
 
-   
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyDequeX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyDequeX.java
index 7fc54d6f..e2929989 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyDequeX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyDequeX.java
@@ -39,6 +39,7 @@
 
 import lombok.Getter;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended Deque type {@see java.util.Deque}
  * Extended Deque operations execute lazily e.g.
@@ -65,20 +66,22 @@
  *
  * @param <T> the type of elements held in this collection
  */
-public class LazyDequeX<T> extends AbstractFluentCollectionX<T> implements DequeX<T> {
-    private final  LazyFluentCollection<T,Deque<T>> lazy;
+public class LazyDequeX<T> extends AbstractFluentCollectionX<T>implements DequeX<T> {
+    private final LazyFluentCollection<T, Deque<T>> lazy;
     @Getter
-    private final Collector<T,?,Deque<T>> collector;
-    
+    private final Collector<T, ?, Deque<T>> collector;
+
     /**
      * Create a LazyDequeX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyDequeX
      */
-    public static <T> LazyDequeX<T> fromStreamS(Stream<T> stream){
-        return new LazyDequeX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyDequeX<T> fromStreamS(Stream<T> stream) {
+        return new LazyDequeX<T>(
+                                 Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyListX that contains the Integers between start and end
      * 
@@ -134,7 +137,7 @@ static <U, T> LazyDequeX<T> unfold(U seed, Function<? super U, Optional<Tuple2<T
     public static <T> LazyDequeX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -147,10 +150,9 @@ public static <T> LazyDequeX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyDequeX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyListX
      */
@@ -158,14 +160,13 @@ public static <T> LazyDequeX<T> iterate(long limit, final T seed, final UnaryOpe
         return Collectors.toCollection(() -> LazyDequeX.of());
     }
 
-   
-
     /**
      * @return An empty LazyListX
      */
     public static <T> LazyDequeX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -186,8 +187,9 @@ public static <T> LazyDequeX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyDequeX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -228,7 +230,7 @@ public static <T> LazyDequeX<T> fromPublisher(Publisher<? extends T> publisher)
      * @return LazyListX from Iterable
      */
     public static <T> LazyDequeX<T> fromIterable(Iterable<T> it) {
-        return fromIterable(DequeX.<T>defaultCollector(), it);
+        return fromIterable(DequeX.<T> defaultCollector(), it);
     }
 
     /**
@@ -241,40 +243,52 @@ public static <T> LazyDequeX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyDequeX<T> fromIterable(Collector<T, ?, Deque<T>> collector, Iterable<T> it) {
         if (it instanceof LazyDequeX)
             return (LazyDequeX<T>) it;
-       
+
         if (it instanceof Deque)
             return new LazyDequeX<T>(
-                                    (Deque<T>) it, collector);
+                                     (Deque<T>) it, collector);
         return new LazyDequeX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                 Flux.fromIterable(it), collector);
     }
-    private LazyDequeX(Deque<T> list,Collector<T,?,Deque<T>> collector){
-        this.lazy = new LazyCollection<>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyDequeX(Deque<T> list, Collector<T, ?, Deque<T>> collector) {
+        this.lazy = new LazyCollection<>(
+                                         list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyDequeX(Deque<T> list){
-        
+
+    private LazyDequeX(Deque<T> list) {
+
         this.collector = DequeX.defaultCollector();
-        this.lazy = new LazyCollection<T,Deque<T>>(list,null,collector);
+        this.lazy = new LazyCollection<T, Deque<T>>(
+                                                    list, null, collector);
     }
-    private LazyDequeX(Flux<T> stream,Collector<T,?,Deque<T>> collector){
-        
+
+    private LazyDequeX(Flux<T> stream, Collector<T, ?, Deque<T>> collector) {
+
         this.collector = collector;
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazyDequeX(Flux<T> stream){
-        
+
+    private LazyDequeX(Flux<T> stream) {
+
         this.collector = DequeX.defaultCollector();
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazyDequeX(){
+
+    private LazyDequeX() {
         this.collector = DequeX.defaultCollector();
-        this.lazy = new LazyCollection<>((Deque)this.collector.supplier().get(),null,collector);
+        this.lazy = new LazyCollection<>(
+                                         (Deque) this.collector.supplier()
+                                                               .get(),
+                                         null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -282,7 +296,9 @@ public void forEach(Consumer<? super T> action) {
         getDeque().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -290,7 +306,9 @@ public Iterator<T> iterator() {
         return getDeque().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -298,7 +316,9 @@ public int size() {
         return getDeque().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -306,7 +326,9 @@ public boolean contains(Object e) {
         return getDeque().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -314,9 +336,9 @@ public boolean equals(Object o) {
         return getDeque().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -324,7 +346,9 @@ public boolean isEmpty() {
         return getDeque().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -332,7 +356,9 @@ public int hashCode() {
         return getDeque().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -340,7 +366,9 @@ public Object[] toArray() {
         return getDeque().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -348,7 +376,9 @@ public boolean removeAll(Collection<?> c) {
         return getDeque().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -356,7 +386,9 @@ public <T> T[] toArray(T[] a) {
         return getDeque().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -364,7 +396,9 @@ public boolean add(T e) {
         return getDeque().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -372,7 +406,9 @@ public boolean remove(Object o) {
         return getDeque().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -380,7 +416,9 @@ public boolean containsAll(Collection<?> c) {
         return getDeque().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -388,7 +426,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getDeque().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -396,7 +436,9 @@ public boolean retainAll(Collection<?> c) {
         return getDeque().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -404,8 +446,9 @@ public void clear() {
         getDeque().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -413,7 +456,9 @@ public String toString() {
         return getDeque().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -421,817 +466,1258 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getDeque().removeIf(filter);
     }
-    
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getDeque().parallelStream();
     }
-    
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getDeque().spliterator();
     }
-   
+
     private Deque<T> getDeque() {
         return lazy.get();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyDequeX<X> stream(Flux<X> stream){
-        return new LazyDequeX<X>(stream);
+    public <X> LazyDequeX<X> stream(Flux<X> stream) {
+        return new LazyDequeX<X>(
+                                 stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
      */
     @Override
     public ReactiveSeq<T> stream() {
-        return ReactiveSeq.fromStream(lazy.get().stream());
+        return ReactiveSeq.fromStream(lazy.get()
+                                          .stream());
     }
+
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#combine(java.
+     * util.function.BiPredicate, java.util.function.BinaryOperator)
      */
     @Override
     public LazyDequeX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyDequeX<T>)super.combine(predicate, op);
+
+        return (LazyDequeX<T>) super.combine(predicate, op);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#reverse()
      */
     @Override
     public LazyDequeX<T> reverse() {
-       
-        return(LazyDequeX<T>)super.reverse();
+
+        return (LazyDequeX<T>) super.reverse();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#filter(java.
+     * util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyDequeX<T>)super.filter(pred);
+
+        return (LazyDequeX<T>) super.filter(pred);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#map(java.util.
+     * function.Function)
      */
     @Override
     public <R> LazyDequeX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyDequeX<R>)super.map(mapper);
+
+        return (LazyDequeX<R>) super.map(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#flatMap(java.
+     * util.function.Function)
      */
     @Override
     public <R> LazyDequeX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyDequeX<R>)super.flatMap(mapper);
+        return (LazyDequeX<R>) super.flatMap(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limit(long)
      */
     @Override
     public LazyDequeX<T> limit(long num) {
-       return (LazyDequeX<T>)super.limit(num);
+        return (LazyDequeX<T>) super.limit(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skip(long)
      */
     @Override
     public LazyDequeX<T> skip(long num) {
-       return (LazyDequeX<T>)super.skip(num);
+        return (LazyDequeX<T>) super.skip(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#takeRight(int)
      */
     @Override
     public LazyDequeX<T> takeRight(int num) {
-       return (LazyDequeX<T>)super.takeRight(num);
+        return (LazyDequeX<T>) super.takeRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#dropRight(int)
      */
     @Override
     public LazyDequeX<T> dropRight(int num) {
-       return (LazyDequeX<T>)super.dropRight(num);
+        return (LazyDequeX<T>) super.dropRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#takeWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyDequeX<T>)super.takeWhile(p);
+        return (LazyDequeX<T>) super.takeWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#dropWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyDequeX<T>)super.dropWhile(p);
+        return (LazyDequeX<T>) super.dropWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#takeUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyDequeX<T>)super.takeUntil(p);
+        return (LazyDequeX<T>) super.takeUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#dropUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyDequeX<T>)super.dropUntil(p);
+        return (LazyDequeX<T>) super.dropUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#trampoline(
+     * java.util.function.Function)
      */
     @Override
     public <R> LazyDequeX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyDequeX<R>)super.trampoline(mapper);
+        return (LazyDequeX<R>) super.trampoline(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#slice(long,
+     * long)
      */
     @Override
     public LazyDequeX<T> slice(long from, long to) {
-       return (LazyDequeX<T>)super.slice(from, to);
+        return (LazyDequeX<T>) super.slice(from, to);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int)
      */
     @Override
     public LazyDequeX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyDequeX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyDequeX<ListX<T>>) super.grouped(groupSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.
+     * util.function.Function, java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyDequeX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyDequeX)super.grouped(classifier, downstream);
+
+        return (LazyDequeX) super.grouped(classifier, downstream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.
+     * util.function.Function)
      */
     @Override
     public <K> LazyDequeX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyDequeX)super.grouped(classifier);
+
+        return (LazyDequeX) super.grouped(classifier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.
+     * Iterable)
      */
     @Override
     public <U> LazyDequeX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyDequeX)super.zip(other);
+
+        return (LazyDequeX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.
+     * Iterable, java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazyDequeX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyDequeX<R>)super.zip(other, zipper);
+
+        return (LazyDequeX<R>) super.zip(other, zipper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int)
      */
     @Override
     public LazyDequeX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyDequeX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyDequeX<ListX<T>>) super.sliding(windowSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int,
+     * int)
      */
     @Override
     public LazyDequeX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyDequeX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyDequeX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(com.
+     * aol.cyclops.Monoid)
      */
     @Override
     public LazyDequeX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyDequeX<T>)super.scanLeft(monoid);
+
+        return (LazyDequeX<T>) super.scanLeft(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(java.
+     * lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazyDequeX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyDequeX<U>) super.scanLeft(seed, function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(com.
+     * aol.cyclops.Monoid)
      */
     @Override
     public LazyDequeX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyDequeX<T>)super.scanRight(monoid);
+
+        return (LazyDequeX<T>) super.scanRight(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(java
+     * .lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazyDequeX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyDequeX<U>)super.scanRight(identity, combiner);
+
+        return (LazyDequeX<U>) super.scanRight(identity, combiner);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.
+     * util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyDequeX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyDequeX<T>)super.sorted(function);
+
+        return (LazyDequeX<T>) super.sorted(function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plus(java.lang
+     * .Object)
      */
     @Override
     public LazyDequeX<T> plus(T e) {
-       
-        return (LazyDequeX<T>)super.plus(e);
+
+        return (LazyDequeX<T>) super.plus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plusAll(java.
+     * util.Collection)
      */
     @Override
     public LazyDequeX<T> plusAll(Collection<? extends T> list) {
-       
-        return (LazyDequeX<T>)super.plusAll(list);
+
+        return (LazyDequeX<T>) super.plusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minus(java.
+     * lang.Object)
      */
     @Override
     public LazyDequeX<T> minus(Object e) {
-       
-        return (LazyDequeX<T>)super.minus(e);
+
+        return (LazyDequeX<T>) super.minus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minusAll(java.
+     * util.Collection)
      */
     @Override
     public LazyDequeX<T> minusAll(Collection<?> list) {
-       
-        return (LazyDequeX<T>)super.minusAll(list);
+
+        return (LazyDequeX<T>) super.minusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plusLazy(java.
+     * lang.Object)
      */
     @Override
     public LazyDequeX<T> plusLazy(T e) {
-       
-        return (LazyDequeX<T>)super.plusLazy(e);
+
+        return (LazyDequeX<T>) super.plusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazyDequeX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyDequeX<T>)super.plusAllLazy(list);
+
+        return (LazyDequeX<T>) super.plusAllLazy(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minusLazy(java
+     * .lang.Object)
      */
     @Override
     public LazyDequeX<T> minusLazy(Object e) {
-       
-        return (LazyDequeX<T>)super.minusLazy(e);
+
+        return (LazyDequeX<T>) super.minusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazyDequeX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyDequeX<T>)super.minusAllLazy(list);
+
+        return (LazyDequeX<T>) super.minusAllLazy(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(int)
      */
     @Override
     public LazyDequeX<T> cycle(int times) {
-       
-        return (LazyDequeX<T>)super.cycle(times);
+
+        return (LazyDequeX<T>) super.cycle(times);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(com.aol.
+     * cyclops.Monoid, int)
      */
     @Override
     public LazyDequeX<T> cycle(Monoid<T> m, int times) {
-       
-        return (LazyDequeX<T>)super.cycle(m, times);
+
+        return (LazyDequeX<T>) super.cycle(m, times);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycleWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return (LazyDequeX<T>)super.cycleWhile(predicate);
+
+        return (LazyDequeX<T>) super.cycleWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycleUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return (LazyDequeX<T>)super.cycleUntil(predicate);
+
+        return (LazyDequeX<T>) super.cycleUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip(org.jooq.
+     * lambda.Seq)
      */
     @Override
     public <U> LazyDequeX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyDequeX)super.zip(other);
+
+        return (LazyDequeX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip3(java.util
+     * .stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyDequeX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyDequeX)super.zip3(second, third);
+
+        return (LazyDequeX) super.zip3(second, third);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip4(java.util
+     * .stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazyDequeX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazyDequeX)super.zip4(second, third, fourth);
+
+        return (LazyDequeX) super.zip4(second, third, fourth);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zipWithIndex()
      */
     @Override
     public LazyDequeX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyDequeX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyDequeX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#distinct()
      */
     @Override
     public LazyDequeX<T> distinct() {
-       
-        return (LazyDequeX<T>)super.distinct();
+
+        return (LazyDequeX<T>) super.distinct();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sorted()
      */
     @Override
     public LazyDequeX<T> sorted() {
-       
-        return (LazyDequeX<T>)super.sorted();
+
+        return (LazyDequeX<T>) super.sorted();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.
+     * util.Comparator)
      */
     @Override
     public LazyDequeX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyDequeX<T>)super.sorted(c);
+
+        return (LazyDequeX<T>) super.sorted(c);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skipWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyDequeX<T>)super.skipWhile(p);
+
+        return (LazyDequeX<T>) super.skipWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skipUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyDequeX<T>)super.skipUntil(p);
+
+        return (LazyDequeX<T>) super.skipUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limitWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyDequeX<T>)super.limitWhile(p);
+
+        return (LazyDequeX<T>) super.limitWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limitUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyDequeX<T>)super.limitUntil(p);
+
+        return (LazyDequeX<T>) super.limitUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#intersperse(
+     * java.lang.Object)
      */
     @Override
     public LazyDequeX<T> intersperse(T value) {
-       
-        return (LazyDequeX<T>)super.intersperse(value);
+
+        return (LazyDequeX<T>) super.intersperse(value);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#shuffle()
      */
     @Override
     public LazyDequeX<T> shuffle() {
-       
-        return (LazyDequeX<T>)super.shuffle();
+
+        return (LazyDequeX<T>) super.shuffle();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skipLast(int)
      */
     @Override
     public LazyDequeX<T> skipLast(int num) {
-       
-        return (LazyDequeX<T>)super.skipLast(num);
+
+        return (LazyDequeX<T>) super.skipLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limitLast(int)
      */
     @Override
     public LazyDequeX<T> limitLast(int num) {
-       
-        return (LazyDequeX<T>)super.limitLast(num);
+
+        return (LazyDequeX<T>) super.limitLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmpty(java.
+     * lang.Object)
      */
     @Override
     public LazyDequeX<T> onEmpty(T value) {
-       
-        return (LazyDequeX<T>)super.onEmpty(value);
+
+        return (LazyDequeX<T>) super.onEmpty(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyGet(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyDequeX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyDequeX<T>)super.onEmptyGet(supplier);
+
+        return (LazyDequeX<T>) super.onEmptyGet(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyThrow(
+     * java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyDequeX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyDequeX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyDequeX<T>) super.onEmptyThrow(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#shuffle(java.
+     * util.Random)
      */
     @Override
     public LazyDequeX<T> shuffle(Random random) {
-       
-        return (LazyDequeX<T>)super.shuffle(random);
+
+        return (LazyDequeX<T>) super.shuffle(random);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#ofType(java.
+     * lang.Class)
      */
     @Override
     public <U> LazyDequeX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyDequeX<U>)super.ofType(type);
+
+        return (LazyDequeX<U>) super.ofType(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#filterNot(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyDequeX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyDequeX<T>)super.filterNot(fn);
+
+        return (LazyDequeX<T>) super.filterNot(fn);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#notNull()
      */
     @Override
     public LazyDequeX<T> notNull() {
-       
-        return (LazyDequeX<T>)super.notNull();
+
+        return (LazyDequeX<T>) super.notNull();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java
+     * .util.stream.Stream)
      */
     @Override
     public LazyDequeX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyDequeX<T>)(super.removeAll(stream));
+
+        return (LazyDequeX<T>) (super.removeAll(stream));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(org.
+     * jooq.lambda.Seq)
      */
     @Override
     public LazyDequeX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyDequeX<T>)super.removeAll(stream);
+
+        return (LazyDequeX<T>) super.removeAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java
+     * .lang.Iterable)
      */
     @Override
     public LazyDequeX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyDequeX<T>)super.removeAll(it);
+
+        return (LazyDequeX<T>) super.removeAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java
+     * .lang.Object[])
      */
     @Override
     public LazyDequeX<T> removeAll(T... values) {
-       
-        return (LazyDequeX<T>)super.removeAll(values);
+
+        return (LazyDequeX<T>) super.removeAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java
+     * .lang.Iterable)
      */
     @Override
     public LazyDequeX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyDequeX<T>)super.retainAll(it);
+
+        return (LazyDequeX<T>) super.retainAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java
+     * .util.stream.Stream)
      */
     @Override
     public LazyDequeX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyDequeX<T>)super.retainAll(stream);
+
+        return (LazyDequeX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(org.
+     * jooq.lambda.Seq)
      */
     @Override
     public LazyDequeX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyDequeX<T>)super.retainAll(stream);
+
+        return (LazyDequeX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java
+     * .lang.Object[])
      */
     @Override
     public LazyDequeX<T> retainAll(T... values) {
-       
-        return (LazyDequeX<T>)super.retainAll(values);
+
+        return (LazyDequeX<T>) super.retainAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cast(java.lang
+     * .Class)
      */
     @Override
     public <U> LazyDequeX<U> cast(Class<? extends U> type) {
-       
-        return (LazyDequeX<U>)super.cast(type);
+
+        return (LazyDequeX<U>) super.cast(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#patternMatch(
+     * java.util.function.Function, java.util.function.Supplier)
      */
     @Override
     public <R> LazyDequeX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyDequeX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyDequeX<R>) super.patternMatch(case1, otherwise);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#permutations()
      */
     @Override
     public LazyDequeX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyDequeX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyDequeX<ReactiveSeq<T>>) super.permutations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#combinations(
+     * int)
      */
     @Override
     public LazyDequeX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyDequeX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyDequeX<ReactiveSeq<T>>) super.combinations(size);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#combinations()
      */
     @Override
     public LazyDequeX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyDequeX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyDequeX<ReactiveSeq<T>>) super.combinations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyDequeX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyDequeX<C>)super.grouped(size, supplier);
+
+        return (LazyDequeX<C>) super.grouped(size, supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyDequeX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyDequeX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyDequeX<ListX<T>>) super.groupedUntil(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyDequeX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyDequeX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyDequeX<ListX<T>>) super.groupedWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyDequeX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyDequeX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyDequeX<C>) super.groupedWhile(predicate, factory);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyDequeX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyDequeX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyDequeX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** ListX methods **/
 
-    /* Makes a defensive copy of this ListX replacing the value at i with the specified element
-     *  (non-Javadoc)
-     * @see com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(int, java.lang.Object)
+    /*
+     * Makes a defensive copy of this ListX replacing the value at i with the
+     * specified element (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(
+     * int, java.lang.Object)
      */
-    public LazyDequeX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyDequeX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#unit(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #unit(java.util.Collection)
      */
     @Override
-    public <R> LazyDequeX<R> unit(Collection<R> col){
+    public <R> LazyDequeX<R> unit(Collection<R> col) {
         return LazyDequeX.fromIterable(col);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
      */
     @Override
-    public  <R> LazyDequeX<R> unit(R value){
+    public <R> LazyDequeX<R> unit(R value) {
         return LazyDequeX.singleton(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#unitIterator(java.util.Iterator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#unitIterator(java.util.Iterator)
      */
     @Override
-    public <R> LazyDequeX<R> unitIterator(Iterator<R> it){
-        return LazyDequeX.fromIterable(()->it);
+    public <R> LazyDequeX<R> unitIterator(Iterator<R> it) {
+        return LazyDequeX.fromIterable(() -> it);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyDequeX<T> plusInOrder(T e) {
-        
-        return (LazyDequeX<T>)super.plusInOrder(e);
+
+        return (LazyDequeX<T>) super.plusInOrder(e);
     }
-    
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <T1> LazyDequeX<T1> from(Collection<T1> c) {
-        if(c instanceof List)
-            return new LazyDequeX<T1>((Deque)c,(Collector)collector);
-      return new LazyDequeX<T1>((Deque)c.stream().collect(DequeX.defaultCollector()),(Collector)this.collector);
+        if (c instanceof List)
+            return new LazyDequeX<T1>(
+                                      (Deque) c, (Collector) collector);
+        return new LazyDequeX<T1>(
+                                  (Deque) c.stream()
+                                           .collect(DequeX.defaultCollector()),
+                                  (Collector) this.collector);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyDequeX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyDequeX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyDequeX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyDequeX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyDequeX)super.peek(c);
+
+        return (LazyDequeX) super.peek(c);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyDequeX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyDequeX<R>)super.zip(other, zipper);
+    public <U, R> LazyDequeX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyDequeX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyDequeX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyDequeX<R>)super.zip(other, zipper);
+    public <U, R> LazyDequeX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyDequeX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyDequeX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyDequeX)super.zip(other);
+
+        return (LazyDequeX) super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyDequeX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyDequeX<R>)super.zip(fn, publisher);
+
+        return (LazyDequeX<R>) super.zip(fn, publisher);
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.DequeX#fromStream(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.DequeX#fromStream(
+     * java.util.stream.Stream)
      */
     @Override
     public <X> LazyDequeX<X> fromStream(Stream<X> stream) {
-        Deque<X> list = (Deque<X>) stream.collect((Collector)getCollector());
-        return new LazyDequeX<X>(list, (Collector)getCollector());
+        Deque<X> list = (Deque<X>) stream.collect((Collector) getCollector());
+        return new LazyDequeX<X>(
+                                 list, (Collector) getCollector());
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyDequeX<T> onEmptySwitch(Supplier<? extends Deque<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
     }
-    
 
     /**
      * @param e
@@ -1240,6 +1726,7 @@ public LazyDequeX<T> onEmptySwitch(Supplier<? extends Deque<T>> supplier) {
     public void addFirst(T e) {
         getDeque().addFirst(e);
     }
+
     /**
      * @param e
      * @see java.util.Deque#addLast(java.lang.Object)
@@ -1247,6 +1734,7 @@ public void addFirst(T e) {
     public void addLast(T e) {
         getDeque().addLast(e);
     }
+
     /**
      * @param e
      * @return
@@ -1255,6 +1743,7 @@ public void addLast(T e) {
     public boolean offerFirst(T e) {
         return getDeque().offerFirst(e);
     }
+
     /**
      * @param e
      * @return
@@ -1263,6 +1752,7 @@ public boolean offerFirst(T e) {
     public boolean offerLast(T e) {
         return getDeque().offerLast(e);
     }
+
     /**
      * @return
      * @see java.util.Deque#removeFirst()
@@ -1270,6 +1760,7 @@ public boolean offerLast(T e) {
     public T removeFirst() {
         return getDeque().removeFirst();
     }
+
     /**
      * @return
      * @see java.util.Deque#removeLast()
@@ -1277,6 +1768,7 @@ public T removeFirst() {
     public T removeLast() {
         return getDeque().removeLast();
     }
+
     /**
      * @return
      * @see java.util.Deque#pollFirst()
@@ -1284,6 +1776,7 @@ public T removeLast() {
     public T pollFirst() {
         return getDeque().pollFirst();
     }
+
     /**
      * @return
      * @see java.util.Deque#pollLast()
@@ -1291,6 +1784,7 @@ public T pollFirst() {
     public T pollLast() {
         return getDeque().pollLast();
     }
+
     /**
      * @return
      * @see java.util.Deque#getFirst()
@@ -1298,6 +1792,7 @@ public T pollLast() {
     public T getFirst() {
         return getDeque().getFirst();
     }
+
     /**
      * @return
      * @see java.util.Deque#getLast()
@@ -1305,6 +1800,7 @@ public T getFirst() {
     public T getLast() {
         return getDeque().getLast();
     }
+
     /**
      * @return
      * @see java.util.Deque#peekFirst()
@@ -1312,6 +1808,7 @@ public T getLast() {
     public T peekFirst() {
         return getDeque().peekFirst();
     }
+
     /**
      * @return
      * @see java.util.Deque#peekLast()
@@ -1319,6 +1816,7 @@ public T peekFirst() {
     public T peekLast() {
         return getDeque().peekLast();
     }
+
     /**
      * @param o
      * @return
@@ -1327,6 +1825,7 @@ public T peekLast() {
     public boolean removeFirstOccurrence(Object o) {
         return getDeque().removeFirstOccurrence(o);
     }
+
     /**
      * @param o
      * @return
@@ -1335,6 +1834,7 @@ public boolean removeFirstOccurrence(Object o) {
     public boolean removeLastOccurrence(Object o) {
         return getDeque().removeLastOccurrence(o);
     }
+
     /**
      * @param e
      * @return
@@ -1343,6 +1843,7 @@ public boolean removeLastOccurrence(Object o) {
     public boolean offer(T e) {
         return getDeque().offer(e);
     }
+
     /**
      * @return
      * @see java.util.Deque#remove()
@@ -1350,6 +1851,7 @@ public boolean offer(T e) {
     public T remove() {
         return getDeque().remove();
     }
+
     /**
      * @return
      * @see java.util.Deque#poll()
@@ -1357,6 +1859,7 @@ public T remove() {
     public T poll() {
         return getDeque().poll();
     }
+
     /**
      * @return
      * @see java.util.Deque#element()
@@ -1364,6 +1867,7 @@ public T poll() {
     public T element() {
         return getDeque().element();
     }
+
     /**
      * @return
      * @see java.util.Deque#peek()
@@ -1371,6 +1875,7 @@ public T element() {
     public T peek() {
         return getDeque().peek();
     }
+
     /**
      * @param e
      * @see java.util.Deque#push(java.lang.Object)
@@ -1378,6 +1883,7 @@ public T peek() {
     public void push(T e) {
         getDeque().push(e);
     }
+
     /**
      * @return
      * @see java.util.Deque#pop()
@@ -1385,6 +1891,7 @@ public void push(T e) {
     public T pop() {
         return getDeque().pop();
     }
+
     /**
      * @return
      * @see java.util.Deque#descendingIterator()
@@ -1392,5 +1899,5 @@ public T pop() {
     public Iterator<T> descendingIterator() {
         return getDeque().descendingIterator();
     }
-    
+
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyListX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyListX.java
index 16f0a62b..52b9bd2d 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyListX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyListX.java
@@ -40,6 +40,7 @@
 
 import lombok.Getter;
 import reactor.core.publisher.Flux;
+
 /**
  * An extended List type {@see java.util.List}
  * Extended List operations execute lazily e.g.
@@ -66,21 +67,22 @@
  *
  * @param <T> the type of elements held in this collection
  */
-public class LazyListX<T> extends AbstractFluentCollectionX<T> implements ListX<T> {
-    private final  LazyFluentCollection<T,List<T>> lazy;
+public class LazyListX<T> extends AbstractFluentCollectionX<T>implements ListX<T> {
+    private final LazyFluentCollection<T, List<T>> lazy;
     @Getter
-    private final Collector<T,?,List<T>> collector;
-    
-    
+    private final Collector<T, ?, List<T>> collector;
+
     /**
      * Create a LazyListX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyListX
      */
-    public static <T> LazyListX<T> fromStreamS(Stream<T> stream){
-        return new LazyListX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyListX<T> fromStreamS(Stream<T> stream) {
+        return new LazyListX<T>(
+                                Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyListX that contains the Integers between start and end
      * 
@@ -136,7 +138,7 @@ public static <U, T> LazyListX<T> unfold(U seed, Function<? super U, Optional<Tu
     public static <T> LazyListX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -149,10 +151,9 @@ public static <T> LazyListX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyListX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyListX
      */
@@ -160,14 +161,13 @@ public static <T> LazyListX<T> iterate(long limit, final T seed, final UnaryOper
         return Collectors.toCollection(() -> LazyListX.of());
     }
 
-   
-
     /**
      * @return An empty LazyListX
      */
     public static <T> LazyListX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -188,8 +188,9 @@ public static <T> LazyListX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyListX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -230,7 +231,7 @@ public static <T> LazyListX<T> fromPublisher(Publisher<? extends T> publisher) {
      * @return LazyListX from Iterable
      */
     public static <T> LazyListX<T> fromIterable(Iterable<T> it) {
-        return fromIterable(ListX.<T>defaultCollector(), it);
+        return fromIterable(ListX.<T> defaultCollector(), it);
     }
 
     /**
@@ -243,40 +244,52 @@ public static <T> LazyListX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyListX<T> fromIterable(Collector<T, ?, List<T>> collector, Iterable<T> it) {
         if (it instanceof LazyListX)
             return (LazyListX<T>) it;
-       
+
         if (it instanceof List)
             return new LazyListX<T>(
                                     (List<T>) it, collector);
         return new LazyListX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                Flux.fromIterable(it), collector);
     }
-    private LazyListX(List<T> list,Collector<T,?,List<T>> collector){
-        this.lazy = new LazyCollection<>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyListX(List<T> list, Collector<T, ?, List<T>> collector) {
+        this.lazy = new LazyCollection<>(
+                                         list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyListX(List<T> list){
-        
+
+    private LazyListX(List<T> list) {
+
         this.collector = ListX.defaultCollector();
-        this.lazy = new LazyCollection<T,List<T>>(list,null,collector);
+        this.lazy = new LazyCollection<T, List<T>>(
+                                                   list, null, collector);
     }
-    private LazyListX(Flux<T> stream,Collector<T,?,List<T>> collector){
-        
+
+    private LazyListX(Flux<T> stream, Collector<T, ?, List<T>> collector) {
+
         this.collector = collector;
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazyListX(Flux<T> stream){
-        
+
+    private LazyListX(Flux<T> stream) {
+
         this.collector = ListX.defaultCollector();
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazyListX(){
+
+    private LazyListX() {
         this.collector = ListX.defaultCollector();
-        this.lazy = new LazyCollection<>((List)this.collector.supplier().get(),null,collector);
+        this.lazy = new LazyCollection<>(
+                                         (List) this.collector.supplier()
+                                                              .get(),
+                                         null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -284,7 +297,9 @@ public void forEach(Consumer<? super T> action) {
         getList().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -292,7 +307,9 @@ public Iterator<T> iterator() {
         return getList().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -300,7 +317,9 @@ public int size() {
         return getList().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -308,7 +327,9 @@ public boolean contains(Object e) {
         return getList().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -316,9 +337,9 @@ public boolean equals(Object o) {
         return getList().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -326,7 +347,9 @@ public boolean isEmpty() {
         return getList().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -334,7 +357,9 @@ public int hashCode() {
         return getList().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -342,7 +367,9 @@ public Object[] toArray() {
         return getList().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -350,7 +377,9 @@ public boolean removeAll(Collection<?> c) {
         return getList().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -358,7 +387,9 @@ public <T> T[] toArray(T[] a) {
         return getList().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -366,7 +397,9 @@ public boolean add(T e) {
         return getList().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -374,7 +407,9 @@ public boolean remove(Object o) {
         return getList().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -382,7 +417,9 @@ public boolean containsAll(Collection<?> c) {
         return getList().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -390,7 +427,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getList().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -398,7 +437,9 @@ public boolean retainAll(Collection<?> c) {
         return getList().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -406,8 +447,9 @@ public void clear() {
         getList().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -415,7 +457,9 @@ public String toString() {
         return getList().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -423,958 +467,1452 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#addAll(int, java.util.Collection)
      */
     @Override
     public boolean addAll(int index, Collection<? extends T> c) {
         return getList().addAll(index, c);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#replaceAll(java.util.function.UnaryOperator)
      */
     @Override
     public void replaceAll(UnaryOperator<T> operator) {
         getList().replaceAll(operator);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getList().removeIf(filter);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#sort(java.util.Comparator)
      */
     @Override
-    public  void sort(Comparator<? super T> c) {
+    public void sort(Comparator<? super T> c) {
         getList().sort(c);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#get(int)
      */
     @Override
     public T get(int index) {
         return getList().get(index);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#set(int, java.lang.Object)
      */
     @Override
     public T set(int index, T element) {
         return getList().set(index, element);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#add(int, java.lang.Object)
      */
     @Override
     public void add(int index, T element) {
         getList().add(index, element);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#remove(int)
      */
     @Override
     public T remove(int index) {
         return getList().remove(index);
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getList().parallelStream();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#indexOf(java.lang.Object)
      */
     @Override
     public int indexOf(Object o) {
-        // return stream().zipWithIndex().filter(t->Objects.equals(t.v1,o)).findFirst().get().v2.intValue();
+        // return
+        // stream().zipWithIndex().filter(t->Objects.equals(t.v1,o)).findFirst().get().v2.intValue();
         return getList().indexOf(o);
     }
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#lastIndexOf(java.lang.Object)
      */
     @Override
     public int lastIndexOf(Object o) {
         return getList().lastIndexOf(o);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#listIterator()
      */
     @Override
     public ListIterator<T> listIterator() {
         return getList().listIterator();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.List#listIterator(int)
      */
     @Override
     public ListIterator<T> listIterator(int index) {
         return getList().listIterator(index);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#subList(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#subList(int,
+     * int)
      */
     @Override
     public LazyListX<T> subList(int fromIndex, int toIndex) {
-        return new LazyListX<T>(getList().subList(fromIndex, toIndex),getCollector());
+        return new LazyListX<T>(
+                                getList().subList(fromIndex, toIndex), getCollector());
     }
-  
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getList().spliterator();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     @Override
     public int compareTo(T o) {
-        if(o instanceof List){
-            List l = (List)o;
-            if(this.size()==l.size()){
+        if (o instanceof List) {
+            List l = (List) o;
+            if (this.size() == l.size()) {
                 Iterator i1 = iterator();
                 Iterator i2 = l.iterator();
-                if(i1.hasNext()){
-                    if(i2.hasNext()){
-                        int comp = Comparator.<Comparable>naturalOrder().compare((Comparable)i1.next(), (Comparable)i2.next());
-                        if(comp!=0)
+                if (i1.hasNext()) {
+                    if (i2.hasNext()) {
+                        int comp = Comparator.<Comparable> naturalOrder()
+                                             .compare((Comparable) i1.next(), (Comparable) i2.next());
+                        if (comp != 0)
                             return comp;
                     }
                     return 1;
-                }
-                else{
-                    if(i2.hasNext())
+                } else {
+                    if (i2.hasNext())
                         return -1;
                     else
                         return 0;
                 }
             }
-            return this.size() - ((List)o).size();
-        }
-        else
+            return this.size() - ((List) o).size();
+        } else
             return 1;
-            
-            
+
     }
+
     private List<T> getList() {
         return lazy.get();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyListX<X> stream(Flux<X> stream){
-        return new LazyListX<X>(stream);
+    public <X> LazyListX<X> stream(Flux<X> stream) {
+        return new LazyListX<X>(
+                                stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
      */
     @Override
     public ReactiveSeq<T> stream() {
-        return ReactiveSeq.fromStream(lazy.get().stream());
+        return ReactiveSeq.fromStream(lazy.get()
+                                          .stream());
     }
+
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#combine(java.
+     * util.function.BiPredicate, java.util.function.BinaryOperator)
      */
     @Override
     public LazyListX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyListX<T>)super.combine(predicate, op);
+
+        return (LazyListX<T>) super.combine(predicate, op);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#reverse()
      */
     @Override
     public LazyListX<T> reverse() {
-       
-        return(LazyListX<T>)super.reverse();
+
+        return (LazyListX<T>) super.reverse();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#filter(java.
+     * util.function.Predicate)
      */
     @Override
     public LazyListX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyListX<T>)super.filter(pred);
+
+        return (LazyListX<T>) super.filter(pred);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#map(java.util.
+     * function.Function)
      */
     @Override
     public <R> LazyListX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyListX<R>)super.map(mapper);
+
+        return (LazyListX<R>) super.map(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#flatMap(java.
+     * util.function.Function)
      */
     @Override
     public <R> LazyListX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyListX<R>)super.flatMap(mapper);
+        return (LazyListX<R>) super.flatMap(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limit(long)
      */
     @Override
     public LazyListX<T> limit(long num) {
-       return (LazyListX<T>)super.limit(num);
+        return (LazyListX<T>) super.limit(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skip(long)
      */
     @Override
     public LazyListX<T> skip(long num) {
-       return (LazyListX<T>)super.skip(num);
+        return (LazyListX<T>) super.skip(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#takeRight(int)
      */
     @Override
     public LazyListX<T> takeRight(int num) {
-       return (LazyListX<T>)super.takeRight(num);
+        return (LazyListX<T>) super.takeRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#dropRight(int)
      */
     @Override
     public LazyListX<T> dropRight(int num) {
-       return (LazyListX<T>)super.dropRight(num);
+        return (LazyListX<T>) super.dropRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#takeWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyListX<T>)super.takeWhile(p);
+        return (LazyListX<T>) super.takeWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#dropWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyListX<T>)super.dropWhile(p);
+        return (LazyListX<T>) super.dropWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#takeUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyListX<T>)super.takeUntil(p);
+        return (LazyListX<T>) super.takeUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#dropUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyListX<T>)super.dropUntil(p);
+        return (LazyListX<T>) super.dropUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#trampoline(
+     * java.util.function.Function)
      */
     @Override
     public <R> LazyListX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyListX<R>)super.trampoline(mapper);
+        return (LazyListX<R>) super.trampoline(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#slice(long,
+     * long)
      */
     @Override
     public LazyListX<T> slice(long from, long to) {
-       return (LazyListX<T>)super.slice(from, to);
+        return (LazyListX<T>) super.slice(from, to);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int)
      */
     @Override
     public LazyListX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyListX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyListX<ListX<T>>) super.grouped(groupSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.
+     * util.function.Function, java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyListX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyListX)super.grouped(classifier, downstream);
+
+        return (LazyListX) super.grouped(classifier, downstream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(java.
+     * util.function.Function)
      */
     @Override
     public <K> LazyListX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyListX)super.grouped(classifier);
+
+        return (LazyListX) super.grouped(classifier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.
+     * Iterable)
      */
     @Override
     public <U> LazyListX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyListX)super.zip(other);
+
+        return (LazyListX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip(java.lang.
+     * Iterable, java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazyListX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyListX<R>)super.zip(other, zipper);
+
+        return (LazyListX<R>) super.zip(other, zipper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int)
      */
     @Override
     public LazyListX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyListX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyListX<ListX<T>>) super.sliding(windowSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sliding(int,
+     * int)
      */
     @Override
     public LazyListX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyListX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyListX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(com.
+     * aol.cyclops.Monoid)
      */
     @Override
     public LazyListX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyListX<T>)super.scanLeft(monoid);
+
+        return (LazyListX<T>) super.scanLeft(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanLeft(java.
+     * lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazyListX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyListX<U>) super.scanLeft(seed, function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(com.
+     * aol.cyclops.Monoid)
      */
     @Override
     public LazyListX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyListX<T>)super.scanRight(monoid);
+
+        return (LazyListX<T>) super.scanRight(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#scanRight(java
+     * .lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazyListX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyListX<U>)super.scanRight(identity, combiner);
+
+        return (LazyListX<U>) super.scanRight(identity, combiner);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.
+     * util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyListX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyListX<T>)super.sorted(function);
+
+        return (LazyListX<T>) super.sorted(function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plus(java.lang
+     * .Object)
      */
     @Override
     public LazyListX<T> plus(T e) {
-       
-        return (LazyListX<T>)super.plus(e);
+
+        return (LazyListX<T>) super.plus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plusAll(java.
+     * util.Collection)
      */
     @Override
     public LazyListX<T> plusAll(Collection<? extends T> list) {
-       
-        return (LazyListX<T>)super.plusAll(list);
+
+        return (LazyListX<T>) super.plusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minus(java.
+     * lang.Object)
      */
     @Override
     public LazyListX<T> minus(Object e) {
-       
-        return (LazyListX<T>)super.minus(e);
+
+        return (LazyListX<T>) super.minus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minusAll(java.
+     * util.Collection)
      */
     @Override
     public LazyListX<T> minusAll(Collection<?> list) {
-       
-        return (LazyListX<T>)super.minusAll(list);
+
+        return (LazyListX<T>) super.minusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plusLazy(java.
+     * lang.Object)
      */
     @Override
     public LazyListX<T> plusLazy(T e) {
-       
-        return (LazyListX<T>)super.plusLazy(e);
+
+        return (LazyListX<T>) super.plusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazyListX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyListX<T>)super.plusAllLazy(list);
+
+        return (LazyListX<T>) super.plusAllLazy(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minusLazy(java
+     * .lang.Object)
      */
     @Override
     public LazyListX<T> minusLazy(Object e) {
-       
-        return (LazyListX<T>)super.minusLazy(e);
+
+        return (LazyListX<T>) super.minusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazyListX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyListX<T>)super.minusAllLazy(list);
+
+        return (LazyListX<T>) super.minusAllLazy(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(int)
      */
     @Override
     public LazyListX<T> cycle(int times) {
-       
-        return (LazyListX<T>)super.cycle(times);
+
+        return (LazyListX<T>) super.cycle(times);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycle(com.aol.
+     * cyclops.Monoid, int)
      */
     @Override
     public LazyListX<T> cycle(Monoid<T> m, int times) {
-       
-        return (LazyListX<T>)super.cycle(m, times);
+
+        return (LazyListX<T>) super.cycle(m, times);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycleWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyListX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return (LazyListX<T>)super.cycleWhile(predicate);
+
+        return (LazyListX<T>) super.cycleWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cycleUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyListX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return (LazyListX<T>)super.cycleUntil(predicate);
+
+        return (LazyListX<T>) super.cycleUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip(org.jooq.
+     * lambda.Seq)
      */
     @Override
     public <U> LazyListX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyListX)super.zip(other);
+
+        return (LazyListX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip3(java.util
+     * .stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyListX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyListX)super.zip3(second, third);
+
+        return (LazyListX) super.zip3(second, third);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zip4(java.util
+     * .stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazyListX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazyListX)super.zip4(second, third, fourth);
+
+        return (LazyListX) super.zip4(second, third, fourth);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#zipWithIndex()
      */
     @Override
     public LazyListX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyListX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyListX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#distinct()
      */
     @Override
     public LazyListX<T> distinct() {
-       
-        return (LazyListX<T>)super.distinct();
+
+        return (LazyListX<T>) super.distinct();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sorted()
      */
     @Override
     public LazyListX<T> sorted() {
-       
-        return (LazyListX<T>)super.sorted();
+
+        return (LazyListX<T>) super.sorted();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#sorted(java.
+     * util.Comparator)
      */
     @Override
     public LazyListX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyListX<T>)super.sorted(c);
+
+        return (LazyListX<T>) super.sorted(c);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skipWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyListX<T>)super.skipWhile(p);
+
+        return (LazyListX<T>) super.skipWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skipUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyListX<T>)super.skipUntil(p);
+
+        return (LazyListX<T>) super.skipUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limitWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyListX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyListX<T>)super.limitWhile(p);
+
+        return (LazyListX<T>) super.limitWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limitUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyListX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyListX<T>)super.limitUntil(p);
+
+        return (LazyListX<T>) super.limitUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#intersperse(
+     * java.lang.Object)
      */
     @Override
     public LazyListX<T> intersperse(T value) {
-       
-        return (LazyListX<T>)super.intersperse(value);
+
+        return (LazyListX<T>) super.intersperse(value);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#shuffle()
      */
     @Override
     public LazyListX<T> shuffle() {
-       
-        return (LazyListX<T>)super.shuffle();
+
+        return (LazyListX<T>) super.shuffle();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#skipLast(int)
      */
     @Override
     public LazyListX<T> skipLast(int num) {
-       
-        return (LazyListX<T>)super.skipLast(num);
+
+        return (LazyListX<T>) super.skipLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#limitLast(int)
      */
     @Override
     public LazyListX<T> limitLast(int num) {
-       
-        return (LazyListX<T>)super.limitLast(num);
+
+        return (LazyListX<T>) super.limitLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmpty(java.
+     * lang.Object)
      */
     @Override
     public LazyListX<T> onEmpty(T value) {
-       
-        return (LazyListX<T>)super.onEmpty(value);
+
+        return (LazyListX<T>) super.onEmpty(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyGet(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyListX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyListX<T>)super.onEmptyGet(supplier);
+
+        return (LazyListX<T>) super.onEmptyGet(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptyThrow(
+     * java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyListX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyListX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyListX<T>) super.onEmptyThrow(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#shuffle(java.
+     * util.Random)
      */
     @Override
     public LazyListX<T> shuffle(Random random) {
-       
-        return (LazyListX<T>)super.shuffle(random);
+
+        return (LazyListX<T>) super.shuffle(random);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#ofType(java.
+     * lang.Class)
      */
     @Override
     public <U> LazyListX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyListX<U>)super.ofType(type);
+
+        return (LazyListX<U>) super.ofType(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#filterNot(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyListX<T>)super.filterNot(fn);
+
+        return (LazyListX<T>) super.filterNot(fn);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.ListX#notNull()
      */
     @Override
     public LazyListX<T> notNull() {
-       
-        return (LazyListX<T>)super.notNull();
+
+        return (LazyListX<T>) super.notNull();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java
+     * .util.stream.Stream)
      */
     @Override
     public LazyListX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyListX<T>)(super.removeAll(stream));
+
+        return (LazyListX<T>) (super.removeAll(stream));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(org.
+     * jooq.lambda.Seq)
      */
     @Override
     public LazyListX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyListX<T>)super.removeAll(stream);
+
+        return (LazyListX<T>) super.removeAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java
+     * .lang.Iterable)
      */
     @Override
     public LazyListX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyListX<T>)super.removeAll(it);
+
+        return (LazyListX<T>) super.removeAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#removeAll(java
+     * .lang.Object[])
      */
     @Override
     public LazyListX<T> removeAll(T... values) {
-       
-        return (LazyListX<T>)super.removeAll(values);
+
+        return (LazyListX<T>) super.removeAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java
+     * .lang.Iterable)
      */
     @Override
     public LazyListX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyListX<T>)super.retainAll(it);
+
+        return (LazyListX<T>) super.retainAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java
+     * .util.stream.Stream)
      */
     @Override
     public LazyListX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyListX<T>)super.retainAll(stream);
+
+        return (LazyListX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(org.
+     * jooq.lambda.Seq)
      */
     @Override
     public LazyListX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyListX<T>)super.retainAll(stream);
+
+        return (LazyListX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#retainAll(java
+     * .lang.Object[])
      */
     @Override
     public LazyListX<T> retainAll(T... values) {
-       
-        return (LazyListX<T>)super.retainAll(values);
+
+        return (LazyListX<T>) super.retainAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#cast(java.lang
+     * .Class)
      */
     @Override
     public <U> LazyListX<U> cast(Class<? extends U> type) {
-       
-        return (LazyListX<U>)super.cast(type);
+
+        return (LazyListX<U>) super.cast(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#patternMatch(
+     * java.util.function.Function, java.util.function.Supplier)
      */
     @Override
     public <R> LazyListX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyListX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyListX<R>) super.patternMatch(case1, otherwise);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#permutations()
      */
     @Override
     public LazyListX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyListX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyListX<ReactiveSeq<T>>) super.permutations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#combinations(
+     * int)
      */
     @Override
     public LazyListX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyListX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyListX<ReactiveSeq<T>>) super.combinations(size);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#combinations()
      */
     @Override
     public LazyListX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyListX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyListX<ReactiveSeq<T>>) super.combinations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#grouped(int,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyListX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyListX<C>)super.grouped(size, supplier);
+
+        return (LazyListX<C>) super.grouped(size, supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyListX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyListX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyListX<ListX<T>>) super.groupedUntil(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyListX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyListX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyListX<ListX<T>>) super.groupedWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedWhile(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyListX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyListX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyListX<C>) super.groupedWhile(predicate, factory);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#groupedUntil(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyListX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyListX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyListX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** ListX methods **/
 
-    /* Makes a defensive copy of this ListX replacing the value at i with the specified element
-     *  (non-Javadoc)
-     * @see com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(int, java.lang.Object)
+    /*
+     * Makes a defensive copy of this ListX replacing the value at i with the
+     * specified element (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(
+     * int, java.lang.Object)
      */
-    public LazyListX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyListX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#minus(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#minus(int)
      */
     @Override
-    public LazyListX<T> minus(int pos){
+    public LazyListX<T> minus(int pos) {
         remove(pos);
         return this;
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plus(int, java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plus(int,
+     * java.lang.Object)
      */
     @Override
-    public LazyListX<T> plus(int i, T e){
-        add(i,e);
+    public LazyListX<T> plus(int i, T e) {
+        add(i, e);
         return this;
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#plusAll(int, java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#plusAll(int,
+     * java.util.Collection)
      */
     @Override
-    public LazyListX<T> plusAll(int i, Collection<? extends T> list){
-        addAll(i,list);
+    public LazyListX<T> plusAll(int i, Collection<? extends T> list) {
+        addAll(i, list);
         return this;
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#unit(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #unit(java.util.Collection)
      */
     @Override
-    public <R> LazyListX<R> unit(Collection<R> col){
+    public <R> LazyListX<R> unit(Collection<R> col) {
         return LazyListX.fromIterable(col);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
      */
     @Override
-    public  <R> LazyListX<R> unit(R value){
+    public <R> LazyListX<R> unit(R value) {
         return LazyListX.singleton(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#unitIterator(java.util.Iterator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#unitIterator(java.util.Iterator)
      */
     @Override
-    public <R> LazyListX<R> unitIterator(Iterator<R> it){
-        return LazyListX.fromIterable(()->it);
+    public <R> LazyListX<R> unitIterator(Iterator<R> it) {
+        return LazyListX.fromIterable(() -> it);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyListX<T> plusInOrder(T e) {
-        
-        return (LazyListX<T>)super.plusInOrder(e);
+
+        return (LazyListX<T>) super.plusInOrder(e);
     }
-    
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <T1> LazyListX<T1> from(Collection<T1> c) {
-        if(c instanceof List)
-            return new LazyListX<T1>((List)c,(Collector)collector);
-      return new LazyListX<T1>((List)c.stream().collect(Collectors.toList()),(Collector)this.collector);
+        if (c instanceof List)
+            return new LazyListX<T1>(
+                                     (List) c, (Collector) collector);
+        return new LazyListX<T1>(
+                                 (List) c.stream()
+                                         .collect(Collectors.toList()),
+                                 (Collector) this.collector);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyListX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyListX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyListX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyListX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyListX)super.peek(c);
+
+        return (LazyListX) super.peek(c);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyListX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyListX<R>)super.zip(other, zipper);
+    public <U, R> LazyListX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyListX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyListX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyListX<R>)super.zip(other, zipper);
+    public <U, R> LazyListX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyListX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyListX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyListX)super.zip(other);
+
+        return (LazyListX) super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyListX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyListX<R>)super.zip(fn, publisher);
+
+        return (LazyListX<R>) super.zip(fn, publisher);
     }
- 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#fromStream(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#fromStream(
+     * java.util.stream.Stream)
      */
     @Override
     public <X> LazyListX<X> fromStream(Stream<X> stream) {
-        List<X> list = (List<X>) stream.collect((Collector)getCollector());
-        return new LazyListX<X>(list, (Collector)getCollector());
+        List<X> list = (List<X>) stream.collect((Collector) getCollector());
+        return new LazyListX<X>(
+                                list, (Collector) getCollector());
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.ListX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyListX<T> onEmptySwitch(Supplier<? extends List<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
     }
 
-    
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyQueueX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyQueueX.java
index ee08b454..12119e42 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyQueueX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazyQueueX.java
@@ -66,21 +66,22 @@
  *
  * @param <T> the type of elements held in this collection
  */
-public class LazyQueueX<T> extends AbstractFluentCollectionX<T> implements QueueX<T> {
-    private final  LazyFluentCollection<T,Queue<T>> lazy;
+public class LazyQueueX<T> extends AbstractFluentCollectionX<T>implements QueueX<T> {
+    private final LazyFluentCollection<T, Queue<T>> lazy;
     @Getter
-    private final Collector<T,?,Queue<T>> collector;
-    
-    
+    private final Collector<T, ?, Queue<T>> collector;
+
     /**
      * Create a LazyQueueX from a Stream
      * 
      * @param stream to construct a LazyQueueX from
      * @return LazyQueueX
      */
-    public static <T> LazyQueueX<T> fromStreamS(Stream<T> stream){
-        return new LazyQueueX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazyQueueX<T> fromStreamS(Stream<T> stream) {
+        return new LazyQueueX<T>(
+                                 Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazyQueueX that contains the Integers between start and end
      * 
@@ -136,7 +137,7 @@ public static <U, T> LazyQueueX<T> unfold(U seed, Function<? super U, Optional<T
     public static <T> LazyQueueX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -149,10 +150,9 @@ public static <T> LazyQueueX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazyQueueX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazyQueueX
      */
@@ -160,14 +160,13 @@ public static <T> LazyQueueX<T> iterate(long limit, final T seed, final UnaryOpe
         return Collectors.toCollection(() -> LazyQueueX.of());
     }
 
-   
-
     /**
      * @return An empty LazyQueueX
      */
     public static <T> LazyQueueX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -188,8 +187,9 @@ public static <T> LazyQueueX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazyQueueX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -230,7 +230,7 @@ public static <T> LazyQueueX<T> fromPublisher(Publisher<? extends T> publisher)
      * @return LazyQueueX from Iterable
      */
     public static <T> LazyQueueX<T> fromIterable(Iterable<T> it) {
-        return fromIterable(QueueX.<T>defaultCollector(), it);
+        return fromIterable(QueueX.<T> defaultCollector(), it);
     }
 
     /**
@@ -243,39 +243,51 @@ public static <T> LazyQueueX<T> fromIterable(Iterable<T> it) {
     public static <T> LazyQueueX<T> fromIterable(Collector<T, ?, Queue<T>> collector, Iterable<T> it) {
         if (it instanceof LazyQueueX)
             return (LazyQueueX<T>) it;
-       
+
         if (it instanceof Queue)
             return new LazyQueueX<T>(
-                                    (Queue<T>) it, collector);
+                                     (Queue<T>) it, collector);
         return new LazyQueueX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                 Flux.fromIterable(it), collector);
     }
-    private LazyQueueX(Queue<T> list,Collector<T,?,Queue<T>> collector){
-        this.lazy = new LazyCollection<>(list,null,collector);
-        this.collector=  collector;
+
+    private LazyQueueX(Queue<T> list, Collector<T, ?, Queue<T>> collector) {
+        this.lazy = new LazyCollection<>(
+                                         list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazyQueueX(Queue<T> list){
+
+    private LazyQueueX(Queue<T> list) {
         this.collector = QueueX.defaultCollector();
-        this.lazy = new LazyCollection<T,Queue<T>>(list,null,collector);
+        this.lazy = new LazyCollection<T, Queue<T>>(
+                                                    list, null, collector);
     }
-    private LazyQueueX(Flux<T> stream,Collector<T,?,Queue<T>> collector){
-        
+
+    private LazyQueueX(Flux<T> stream, Collector<T, ?, Queue<T>> collector) {
+
         this.collector = collector;
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazyQueueX(Flux<T> stream){
-        
+
+    private LazyQueueX(Flux<T> stream) {
+
         this.collector = QueueX.defaultCollector();
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazyQueueX(){
+
+    private LazyQueueX() {
         this.collector = QueueX.defaultCollector();
-        this.lazy = new LazyCollection<>((Queue)this.collector.supplier().get(),null,collector);
+        this.lazy = new LazyCollection<>(
+                                         (Queue) this.collector.supplier()
+                                                               .get(),
+                                         null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -283,7 +295,9 @@ public void forEach(Consumer<? super T> action) {
         getQueue().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -291,7 +305,9 @@ public Iterator<T> iterator() {
         return getQueue().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -299,7 +315,9 @@ public int size() {
         return getQueue().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -307,7 +325,9 @@ public boolean contains(Object e) {
         return getQueue().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -315,9 +335,9 @@ public boolean equals(Object o) {
         return getQueue().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -325,7 +345,9 @@ public boolean isEmpty() {
         return getQueue().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -333,7 +355,9 @@ public int hashCode() {
         return getQueue().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -341,7 +365,9 @@ public Object[] toArray() {
         return getQueue().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -349,7 +375,9 @@ public boolean removeAll(Collection<?> c) {
         return getQueue().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -357,7 +385,9 @@ public <T> T[] toArray(T[] a) {
         return getQueue().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -365,7 +395,9 @@ public boolean add(T e) {
         return getQueue().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -373,7 +405,9 @@ public boolean remove(Object o) {
         return getQueue().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -381,7 +415,9 @@ public boolean containsAll(Collection<?> c) {
         return getQueue().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -389,7 +425,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getQueue().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -397,7 +435,9 @@ public boolean retainAll(Collection<?> c) {
         return getQueue().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -405,8 +445,9 @@ public void clear() {
         getQueue().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -414,7 +455,9 @@ public String toString() {
         return getQueue().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -422,852 +465,1311 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getQueue().removeIf(filter);
     }
-   
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getQueue().parallelStream();
     }
-    
-    
-  
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getQueue().spliterator();
     }
-    
+
     private Queue<T> getQueue() {
         return lazy.get();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazyQueueX<X> stream(Flux<X> stream){
-        return new LazyQueueX<X>(stream);
+    public <X> LazyQueueX<X> stream(Flux<X> stream) {
+        return new LazyQueueX<X>(
+                                 stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
      */
     @Override
     public ReactiveSeq<T> stream() {
-        return ReactiveSeq.fromStream(lazy.get().stream());
+        return ReactiveSeq.fromStream(lazy.get()
+                                          .stream());
     }
+
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#combine(java.
+     * util.function.BiPredicate, java.util.function.BinaryOperator)
      */
     @Override
     public LazyQueueX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazyQueueX<T>)super.combine(predicate, op);
+
+        return (LazyQueueX<T>) super.combine(predicate, op);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#reverse()
      */
     @Override
     public LazyQueueX<T> reverse() {
-       
-        return(LazyQueueX<T>)super.reverse();
+
+        return (LazyQueueX<T>) super.reverse();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#filter(java.
+     * util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazyQueueX<T>)super.filter(pred);
+
+        return (LazyQueueX<T>) super.filter(pred);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#map(java.util
+     * .function.Function)
      */
     @Override
     public <R> LazyQueueX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazyQueueX<R>)super.map(mapper);
+
+        return (LazyQueueX<R>) super.map(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#flatMap(java.
+     * util.function.Function)
      */
     @Override
     public <R> LazyQueueX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazyQueueX<R>)super.flatMap(mapper);
+        return (LazyQueueX<R>) super.flatMap(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#limit(long)
      */
     @Override
     public LazyQueueX<T> limit(long num) {
-       return (LazyQueueX<T>)super.limit(num);
+        return (LazyQueueX<T>) super.limit(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#skip(long)
      */
     @Override
     public LazyQueueX<T> skip(long num) {
-       return (LazyQueueX<T>)super.skip(num);
+        return (LazyQueueX<T>) super.skip(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#takeRight(
+     * int)
      */
     @Override
     public LazyQueueX<T> takeRight(int num) {
-       return (LazyQueueX<T>)super.takeRight(num);
+        return (LazyQueueX<T>) super.takeRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#dropRight(
+     * int)
      */
     @Override
     public LazyQueueX<T> dropRight(int num) {
-       return (LazyQueueX<T>)super.dropRight(num);
+        return (LazyQueueX<T>) super.dropRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#takeWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> takeWhile(Predicate<? super T> p) {
-       return (LazyQueueX<T>)super.takeWhile(p);
+        return (LazyQueueX<T>) super.takeWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#dropWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> dropWhile(Predicate<? super T> p) {
-       return (LazyQueueX<T>)super.dropWhile(p);
+        return (LazyQueueX<T>) super.dropWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#takeUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> takeUntil(Predicate<? super T> p) {
-       return (LazyQueueX<T>)super.takeUntil(p);
+        return (LazyQueueX<T>) super.takeUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#dropUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> dropUntil(Predicate<? super T> p) {
-       return(LazyQueueX<T>)super.dropUntil(p);
+        return (LazyQueueX<T>) super.dropUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#trampoline(
+     * java.util.function.Function)
      */
     @Override
     public <R> LazyQueueX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazyQueueX<R>)super.trampoline(mapper);
+        return (LazyQueueX<R>) super.trampoline(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#slice(long,
+     * long)
      */
     @Override
     public LazyQueueX<T> slice(long from, long to) {
-       return (LazyQueueX<T>)super.slice(from, to);
+        return (LazyQueueX<T>) super.slice(from, to);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(int)
      */
     @Override
     public LazyQueueX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazyQueueX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazyQueueX<ListX<T>>) super.grouped(groupSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(java.
+     * util.function.Function, java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazyQueueX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazyQueueX)super.grouped(classifier, downstream);
+
+        return (LazyQueueX) super.grouped(classifier, downstream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(java.
+     * util.function.Function)
      */
     @Override
     public <K> LazyQueueX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazyQueueX)super.grouped(classifier);
+
+        return (LazyQueueX) super.grouped(classifier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#zip(java.lang
+     * .Iterable)
      */
     @Override
     public <U> LazyQueueX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazyQueueX)super.zip(other);
+
+        return (LazyQueueX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#zip(java.lang
+     * .Iterable, java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazyQueueX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazyQueueX<R>)super.zip(other, zipper);
+
+        return (LazyQueueX<R>) super.zip(other, zipper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#sliding(int)
      */
     @Override
     public LazyQueueX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazyQueueX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazyQueueX<ListX<T>>) super.sliding(windowSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#sliding(int,
+     * int)
      */
     @Override
     public LazyQueueX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazyQueueX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazyQueueX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#scanLeft(com.
+     * aol.cyclops.Monoid)
      */
     @Override
     public LazyQueueX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazyQueueX<T>)super.scanLeft(monoid);
+
+        return (LazyQueueX<T>) super.scanLeft(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#scanLeft(java
+     * .lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazyQueueX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazyQueueX<U>) super.scanLeft(seed, function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#scanRight(com
+     * .aol.cyclops.Monoid)
      */
     @Override
     public LazyQueueX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazyQueueX<T>)super.scanRight(monoid);
+
+        return (LazyQueueX<T>) super.scanRight(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#scanRight(
+     * java.lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazyQueueX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazyQueueX<U>)super.scanRight(identity, combiner);
+
+        return (LazyQueueX<U>) super.scanRight(identity, combiner);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#sorted(java.
+     * util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazyQueueX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazyQueueX<T>)super.sorted(function);
+
+        return (LazyQueueX<T>) super.sorted(function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#plus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#plus(java.
+     * lang.Object)
      */
     @Override
     public LazyQueueX<T> plus(T e) {
-       
-        return (LazyQueueX<T>)super.plus(e);
+
+        return (LazyQueueX<T>) super.plus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#plusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#plusAll(java.
+     * util.Collection)
      */
     @Override
     public LazyQueueX<T> plusAll(Collection<? extends T> list) {
-       
-        return (LazyQueueX<T>)super.plusAll(list);
+
+        return (LazyQueueX<T>) super.plusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#minus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#minus(java.
+     * lang.Object)
      */
     @Override
     public LazyQueueX<T> minus(Object e) {
-       
-        return (LazyQueueX<T>)super.minus(e);
+
+        return (LazyQueueX<T>) super.minus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#minusAll(java
+     * .util.Collection)
      */
     @Override
     public LazyQueueX<T> minusAll(Collection<?> list) {
-       
-        return (LazyQueueX<T>)super.minusAll(list);
+
+        return (LazyQueueX<T>) super.minusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#plusLazy(java
+     * .lang.Object)
      */
     @Override
     public LazyQueueX<T> plusLazy(T e) {
-       
-        return (LazyQueueX<T>)super.plusLazy(e);
+
+        return (LazyQueueX<T>) super.plusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#plusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazyQueueX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazyQueueX<T>)super.plusAllLazy(list);
+
+        return (LazyQueueX<T>) super.plusAllLazy(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#minusLazy(
+     * java.lang.Object)
      */
     @Override
     public LazyQueueX<T> minusLazy(Object e) {
-       
-        return (LazyQueueX<T>)super.minusLazy(e);
+
+        return (LazyQueueX<T>) super.minusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#minusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazyQueueX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazyQueueX<T>)super.minusAllLazy(list);
+
+        return (LazyQueueX<T>) super.minusAllLazy(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#cycle(int)
      */
     @Override
     public LazyQueueX<T> cycle(int times) {
-       
-        return (LazyQueueX<T>)super.cycle(times);
+
+        return (LazyQueueX<T>) super.cycle(times);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#cycle(com.aol
+     * .cyclops.Monoid, int)
      */
     @Override
     public LazyQueueX<T> cycle(Monoid<T> m, int times) {
-       
-        return (LazyQueueX<T>)super.cycle(m, times);
+
+        return (LazyQueueX<T>) super.cycle(m, times);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#cycleWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return (LazyQueueX<T>)super.cycleWhile(predicate);
+
+        return (LazyQueueX<T>) super.cycleWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#cycleUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return (LazyQueueX<T>)super.cycleUntil(predicate);
+
+        return (LazyQueueX<T>) super.cycleUntil(predicate);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#zip(org.jooq.
+     * lambda.Seq)
      */
     @Override
     public <U> LazyQueueX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazyQueueX)super.zip(other);
+
+        return (LazyQueueX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#zip3(java.
+     * util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <S, U> LazyQueueX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazyQueueX)super.zip3(second, third);
+
+        return (LazyQueueX) super.zip3(second, third);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#zip4(java.
+     * util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazyQueueX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazyQueueX)super.zip4(second, third, fourth);
+
+        return (LazyQueueX) super.zip4(second, third, fourth);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#zipWithIndex(
+     * )
      */
     @Override
     public LazyQueueX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazyQueueX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazyQueueX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#distinct()
      */
     @Override
     public LazyQueueX<T> distinct() {
-       
-        return (LazyQueueX<T>)super.distinct();
+
+        return (LazyQueueX<T>) super.distinct();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#sorted()
      */
     @Override
     public LazyQueueX<T> sorted() {
-       
-        return (LazyQueueX<T>)super.sorted();
+
+        return (LazyQueueX<T>) super.sorted();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#sorted(java.
+     * util.Comparator)
      */
     @Override
     public LazyQueueX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazyQueueX<T>)super.sorted(c);
+
+        return (LazyQueueX<T>) super.sorted(c);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#skipWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazyQueueX<T>)super.skipWhile(p);
+
+        return (LazyQueueX<T>) super.skipWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#skipUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazyQueueX<T>)super.skipUntil(p);
+
+        return (LazyQueueX<T>) super.skipUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#limitWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazyQueueX<T>)super.limitWhile(p);
+
+        return (LazyQueueX<T>) super.limitWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#limitUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazyQueueX<T>)super.limitUntil(p);
+
+        return (LazyQueueX<T>) super.limitUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#intersperse(
+     * java.lang.Object)
      */
     @Override
     public LazyQueueX<T> intersperse(T value) {
-       
-        return (LazyQueueX<T>)super.intersperse(value);
+
+        return (LazyQueueX<T>) super.intersperse(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#shuffle()
      */
     @Override
     public LazyQueueX<T> shuffle() {
-       
-        return (LazyQueueX<T>)super.shuffle();
+
+        return (LazyQueueX<T>) super.shuffle();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#skipLast(int)
      */
     @Override
     public LazyQueueX<T> skipLast(int num) {
-       
-        return (LazyQueueX<T>)super.skipLast(num);
+
+        return (LazyQueueX<T>) super.skipLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#limitLast(
+     * int)
      */
     @Override
     public LazyQueueX<T> limitLast(int num) {
-       
-        return (LazyQueueX<T>)super.limitLast(num);
+
+        return (LazyQueueX<T>) super.limitLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmpty(java.
+     * lang.Object)
      */
     @Override
     public LazyQueueX<T> onEmpty(T value) {
-       
-        return (LazyQueueX<T>)super.onEmpty(value);
+
+        return (LazyQueueX<T>) super.onEmpty(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmptyGet(
+     * java.util.function.Supplier)
      */
     @Override
     public LazyQueueX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazyQueueX<T>)super.onEmptyGet(supplier);
+
+        return (LazyQueueX<T>) super.onEmptyGet(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmptyThrow(
+     * java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazyQueueX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazyQueueX<T>)super.onEmptyThrow(supplier);
+
+        return (LazyQueueX<T>) super.onEmptyThrow(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#shuffle(java.
+     * util.Random)
      */
     @Override
     public LazyQueueX<T> shuffle(Random random) {
-       
-        return (LazyQueueX<T>)super.shuffle(random);
+
+        return (LazyQueueX<T>) super.shuffle(random);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#ofType(java.
+     * lang.Class)
      */
     @Override
     public <U> LazyQueueX<U> ofType(Class<? extends U> type) {
-       
-        return (LazyQueueX<U>)super.ofType(type);
+
+        return (LazyQueueX<U>) super.ofType(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#filterNot(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazyQueueX<T>)super.filterNot(fn);
+
+        return (LazyQueueX<T>) super.filterNot(fn);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#notNull()
      */
     @Override
     public LazyQueueX<T> notNull() {
-       
-        return (LazyQueueX<T>)super.notNull();
+
+        return (LazyQueueX<T>) super.notNull();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(
+     * java.util.stream.Stream)
      */
     @Override
     public LazyQueueX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazyQueueX<T>)(super.removeAll(stream));
+
+        return (LazyQueueX<T>) (super.removeAll(stream));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(org
+     * .jooq.lambda.Seq)
      */
     @Override
     public LazyQueueX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazyQueueX<T>)super.removeAll(stream);
+
+        return (LazyQueueX<T>) super.removeAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(
+     * java.lang.Iterable)
      */
     @Override
     public LazyQueueX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazyQueueX<T>)super.removeAll(it);
+
+        return (LazyQueueX<T>) super.removeAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#removeAll(
+     * java.lang.Object[])
      */
     @Override
     public LazyQueueX<T> removeAll(T... values) {
-       
-        return (LazyQueueX<T>)super.removeAll(values);
+
+        return (LazyQueueX<T>) super.removeAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(
+     * java.lang.Iterable)
      */
     @Override
     public LazyQueueX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazyQueueX<T>)super.retainAll(it);
+
+        return (LazyQueueX<T>) super.retainAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(
+     * java.util.stream.Stream)
      */
     @Override
     public LazyQueueX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazyQueueX<T>)super.retainAll(stream);
+
+        return (LazyQueueX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(org
+     * .jooq.lambda.Seq)
      */
     @Override
     public LazyQueueX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazyQueueX<T>)super.retainAll(stream);
+
+        return (LazyQueueX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#retainAll(
+     * java.lang.Object[])
      */
     @Override
     public LazyQueueX<T> retainAll(T... values) {
-       
-        return (LazyQueueX<T>)super.retainAll(values);
+
+        return (LazyQueueX<T>) super.retainAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#cast(java.
+     * lang.Class)
      */
     @Override
     public <U> LazyQueueX<U> cast(Class<? extends U> type) {
-       
-        return (LazyQueueX<U>)super.cast(type);
+
+        return (LazyQueueX<U>) super.cast(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#patternMatch(
+     * java.util.function.Function, java.util.function.Supplier)
      */
     @Override
     public <R> LazyQueueX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazyQueueX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazyQueueX<R>) super.patternMatch(case1, otherwise);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#permutations(
+     * )
      */
     @Override
     public LazyQueueX<ReactiveSeq<T>> permutations() {
-       
-        return (LazyQueueX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazyQueueX<ReactiveSeq<T>>) super.permutations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#combinations(
+     * int)
      */
     @Override
     public LazyQueueX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazyQueueX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazyQueueX<ReactiveSeq<T>>) super.combinations(size);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#combinations(
+     * )
      */
     @Override
     public LazyQueueX<ReactiveSeq<T>> combinations() {
-       
-        return (LazyQueueX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazyQueueX<ReactiveSeq<T>>) super.combinations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#grouped(int,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyQueueX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazyQueueX<C>)super.grouped(size, supplier);
+
+        return (LazyQueueX<C>) super.grouped(size, supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazyQueueX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazyQueueX<ListX<T>>) super.groupedUntil(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazyQueueX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazyQueueX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazyQueueX<ListX<T>>) super.groupedWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedWhile(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyQueueX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyQueueX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazyQueueX<C>) super.groupedWhile(predicate, factory);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#groupedUntil(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazyQueueX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazyQueueX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazyQueueX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** QueueX methods **/
 
-    /* Makes a defensive copy of this QueueX replacing the value at i with the specified element
-     *  (non-Javadoc)
-     * @see com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(int, java.lang.Object)
+    /*
+     * Makes a defensive copy of this QueueX replacing the value at i with the
+     * specified element (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(
+     * int, java.lang.Object)
      */
-    public LazyQueueX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazyQueueX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#unit(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #unit(java.util.Collection)
      */
     @Override
-    public <R> LazyQueueX<R> unit(Collection<R> col){
+    public <R> LazyQueueX<R> unit(Collection<R> col) {
         return LazyQueueX.fromIterable(col);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
      */
     @Override
-    public  <R> LazyQueueX<R> unit(R value){
+    public <R> LazyQueueX<R> unit(R value) {
         return LazyQueueX.singleton(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#unitIterator(java.util.Iterator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#unitIterator(java.util.Iterator)
      */
     @Override
-    public <R> LazyQueueX<R> unitIterator(Iterator<R> it){
-        return LazyQueueX.fromIterable(()->it);
+    public <R> LazyQueueX<R> unitIterator(Iterator<R> it) {
+        return LazyQueueX.fromIterable(() -> it);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazyQueueX<T> plusInOrder(T e) {
-        
-        return (LazyQueueX<T>)super.plusInOrder(e);
+
+        return (LazyQueueX<T>) super.plusInOrder(e);
     }
-    
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <T1> LazyQueueX<T1> from(Collection<T1> c) {
-        if(c instanceof List)
-            return new LazyQueueX<T1>((Queue)c,(Collector)collector);
-      return new LazyQueueX<T1>((Queue)c.stream().collect(QueueX.defaultCollector()),(Collector)this.collector);
+        if (c instanceof List)
+            return new LazyQueueX<T1>(
+                                      (Queue) c, (Collector) collector);
+        return new LazyQueueX<T1>(
+                                  (Queue) c.stream()
+                                           .collect(QueueX.defaultCollector()),
+                                  (Collector) this.collector);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazyQueueX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazyQueueX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazyQueueX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazyQueueX<T> peek(Consumer<? super T> c) {
-        
-        return (LazyQueueX)super.peek(c);
+
+        return (LazyQueueX) super.peek(c);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyQueueX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazyQueueX<R>)super.zip(other, zipper);
+    public <U, R> LazyQueueX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyQueueX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazyQueueX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazyQueueX<R>)super.zip(other, zipper);
+    public <U, R> LazyQueueX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazyQueueX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazyQueueX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazyQueueX)super.zip(other);
+
+        return (LazyQueueX) super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazyQueueX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazyQueueX<R>)super.zip(fn, publisher);
+
+        return (LazyQueueX<R>) super.zip(fn, publisher);
     }
- 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#fromStream(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#fromStream(
+     * java.util.stream.Stream)
      */
     @Override
     public <X> LazyQueueX<X> fromStream(Stream<X> stream) {
-        Queue<X> list = (Queue<X>) stream.collect((Collector)getCollector());
-        return new LazyQueueX<X>(list, (Collector)getCollector());
+        Queue<X> list = (Queue<X>) stream.collect((Collector) getCollector());
+        return new LazyQueueX<X>(
+                                 list, (Collector) getCollector());
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.QueueX#onEmptySwitch
+     * (java.util.function.Supplier)
      */
     @Override
     public LazyQueueX<T> onEmptySwitch(Supplier<? extends Queue<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
     }
-    
-   
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Queue#offer(java.lang.Object)
      */
     public boolean offer(T e) {
         return getQueue().offer(e);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Queue#remove()
      */
     public T remove() {
         return getQueue().remove();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Queue#poll()
      */
     public T poll() {
         return getQueue().poll();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Queue#element()
      */
     public T element() {
         return getQueue().element();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Queue#peek()
      */
     public T peek() {
         return getQueue().peek();
     }
 
-    
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySetX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySetX.java
index 5143686e..22ef51f4 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySetX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySetX.java
@@ -70,21 +70,22 @@
  *
  * @param <T> the type of elements held in this collection
  */
-public class LazySetX<T> extends AbstractFluentCollectionX<T> implements SetX<T> {
-    private final  LazyFluentCollection<T,Set<T>> lazy;
+public class LazySetX<T> extends AbstractFluentCollectionX<T>implements SetX<T> {
+    private final LazyFluentCollection<T, Set<T>> lazy;
     @Getter
-    private final Collector<T,?,Set<T>> collector;
-    
-    
+    private final Collector<T, ?, Set<T>> collector;
+
     /**
      * Create a LazySetX from a Stream
      * 
      * @param stream to construct a LazySetX from
      * @return LazySetX
      */
-    public static <T> LazySetX<T> fromStreamS(Stream<T> stream){
-        return new LazySetX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazySetX<T> fromStreamS(Stream<T> stream) {
+        return new LazySetX<T>(
+                               Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazySetX that contains the Integers between start and end
      * 
@@ -140,7 +141,7 @@ public static <U, T> LazySetX<T> unfold(U seed, Function<? super U, Optional<Tup
     public static <T> LazySetX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -153,10 +154,9 @@ public static <T> LazySetX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazySetX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazySetX
      */
@@ -164,14 +164,13 @@ public static <T> LazySetX<T> iterate(long limit, final T seed, final UnaryOpera
         return Collectors.toCollection(() -> LazySetX.of());
     }
 
-   
-
     /**
      * @return An empty LazySetX
      */
     public static <T> LazySetX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -192,8 +191,9 @@ public static <T> LazySetX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazySetX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -234,7 +234,7 @@ public static <T> LazySetX<T> fromPublisher(Publisher<? extends T> publisher) {
      * @return LazySetX from Iterable
      */
     public static <T> LazySetX<T> fromIterable(Iterable<T> it) {
-        return fromIterable(SetX.<T>defaultCollector(), it);
+        return fromIterable(SetX.<T> defaultCollector(), it);
     }
 
     /**
@@ -247,39 +247,51 @@ public static <T> LazySetX<T> fromIterable(Iterable<T> it) {
     public static <T> LazySetX<T> fromIterable(Collector<T, ?, Set<T>> collector, Iterable<T> it) {
         if (it instanceof LazySetX)
             return (LazySetX<T>) it;
-       
+
         if (it instanceof Set)
             return new LazySetX<T>(
-                                    (Set<T>) it, collector);
+                                   (Set<T>) it, collector);
         return new LazySetX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                               Flux.fromIterable(it), collector);
     }
-    private LazySetX(Set<T> list,Collector<T,?,Set<T>> collector){
-        this.lazy = new LazyCollection<>(list,null,collector);
-        this.collector=  collector;
+
+    private LazySetX(Set<T> list, Collector<T, ?, Set<T>> collector) {
+        this.lazy = new LazyCollection<>(
+                                         list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazySetX(Set<T> list){
+
+    private LazySetX(Set<T> list) {
         this.collector = SetX.defaultCollector();
-        this.lazy = new LazyCollection<T,Set<T>>(list,null,collector);
+        this.lazy = new LazyCollection<T, Set<T>>(
+                                                  list, null, collector);
     }
-    private LazySetX(Flux<T> stream,Collector<T,?,Set<T>> collector){
-        
+
+    private LazySetX(Flux<T> stream, Collector<T, ?, Set<T>> collector) {
+
         this.collector = collector;
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazySetX(Flux<T> stream){
-        
+
+    private LazySetX(Flux<T> stream) {
+
         this.collector = SetX.defaultCollector();
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazySetX(){
+
+    private LazySetX() {
         this.collector = SetX.defaultCollector();
-        this.lazy = new LazyCollection<>((Set)this.collector.supplier().get(),null,collector);
+        this.lazy = new LazyCollection<>(
+                                         (Set) this.collector.supplier()
+                                                             .get(),
+                                         null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -287,7 +299,9 @@ public void forEach(Consumer<? super T> action) {
         getSet().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -295,7 +309,9 @@ public Iterator<T> iterator() {
         return getSet().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -303,7 +319,9 @@ public int size() {
         return getSet().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -311,7 +329,9 @@ public boolean contains(Object e) {
         return getSet().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -319,9 +339,9 @@ public boolean equals(Object o) {
         return getSet().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -329,7 +349,9 @@ public boolean isEmpty() {
         return getSet().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -337,7 +359,9 @@ public int hashCode() {
         return getSet().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -345,7 +369,9 @@ public Object[] toArray() {
         return getSet().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -353,7 +379,9 @@ public boolean removeAll(Collection<?> c) {
         return getSet().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -361,7 +389,9 @@ public <T> T[] toArray(T[] a) {
         return getSet().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -369,7 +399,9 @@ public boolean add(T e) {
         return getSet().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -377,7 +409,9 @@ public boolean remove(Object o) {
         return getSet().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -385,7 +419,9 @@ public boolean containsAll(Collection<?> c) {
         return getSet().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -393,7 +429,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getSet().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -401,7 +439,9 @@ public boolean retainAll(Collection<?> c) {
         return getSet().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -409,8 +449,9 @@ public void clear() {
         getSet().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -418,7 +459,9 @@ public String toString() {
         return getSet().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -426,817 +469,1253 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getSet().removeIf(filter);
     }
-   
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getSet().parallelStream();
     }
-    
-    
-  
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getSet().spliterator();
     }
-    
+
     private Set<T> getSet() {
         return lazy.get();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazySetX<X> stream(Flux<X> stream){
-        return new LazySetX<X>(stream);
+    public <X> LazySetX<X> stream(Flux<X> stream) {
+        return new LazySetX<X>(
+                               stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
      */
     @Override
     public ReactiveSeq<T> stream() {
-        return ReactiveSeq.fromStream(lazy.get().stream());
+        return ReactiveSeq.fromStream(lazy.get()
+                                          .stream());
     }
+
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#combine(java.
+     * util.function.BiPredicate, java.util.function.BinaryOperator)
      */
     @Override
     public LazySetX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazySetX<T>)super.combine(predicate, op);
+
+        return (LazySetX<T>) super.combine(predicate, op);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.SetX#reverse()
      */
     @Override
     public LazySetX<T> reverse() {
-       
-        return(LazySetX<T>)super.reverse();
+
+        return (LazySetX<T>) super.reverse();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#filter(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazySetX<T>)super.filter(pred);
+
+        return (LazySetX<T>) super.filter(pred);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#map(java.util.
+     * function.Function)
      */
     @Override
     public <R> LazySetX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazySetX<R>)super.map(mapper);
+
+        return (LazySetX<R>) super.map(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#flatMap(java.
+     * util.function.Function)
      */
     @Override
     public <R> LazySetX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazySetX<R>)super.flatMap(mapper);
+        return (LazySetX<R>) super.flatMap(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#limit(long)
      */
     @Override
     public LazySetX<T> limit(long num) {
-       return (LazySetX<T>)super.limit(num);
+        return (LazySetX<T>) super.limit(num);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.SetX#skip(long)
      */
     @Override
     public LazySetX<T> skip(long num) {
-       return (LazySetX<T>)super.skip(num);
+        return (LazySetX<T>) super.skip(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#takeRight(int)
      */
     @Override
     public LazySetX<T> takeRight(int num) {
-       return (LazySetX<T>)super.takeRight(num);
+        return (LazySetX<T>) super.takeRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#dropRight(int)
      */
     @Override
     public LazySetX<T> dropRight(int num) {
-       return (LazySetX<T>)super.dropRight(num);
+        return (LazySetX<T>) super.dropRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#takeWhile(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> takeWhile(Predicate<? super T> p) {
-       return (LazySetX<T>)super.takeWhile(p);
+        return (LazySetX<T>) super.takeWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#dropWhile(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> dropWhile(Predicate<? super T> p) {
-       return (LazySetX<T>)super.dropWhile(p);
+        return (LazySetX<T>) super.dropWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#takeUntil(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> takeUntil(Predicate<? super T> p) {
-       return (LazySetX<T>)super.takeUntil(p);
+        return (LazySetX<T>) super.takeUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#dropUntil(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> dropUntil(Predicate<? super T> p) {
-       return(LazySetX<T>)super.dropUntil(p);
+        return (LazySetX<T>) super.dropUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#trampoline(java
+     * .util.function.Function)
      */
     @Override
     public <R> LazySetX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazySetX<R>)super.trampoline(mapper);
+        return (LazySetX<R>) super.trampoline(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#slice(long,
+     * long)
      */
     @Override
     public LazySetX<T> slice(long from, long to) {
-       return (LazySetX<T>)super.slice(from, to);
+        return (LazySetX<T>) super.slice(from, to);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(int)
      */
     @Override
     public LazySetX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazySetX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazySetX<ListX<T>>) super.grouped(groupSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(java.
+     * util.function.Function, java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazySetX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazySetX)super.grouped(classifier, downstream);
+
+        return (LazySetX) super.grouped(classifier, downstream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(java.
+     * util.function.Function)
      */
     @Override
     public <K> LazySetX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
-       
-        return (LazySetX)super.grouped(classifier);
+
+        return (LazySetX) super.grouped(classifier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#zip(java.lang.
+     * Iterable)
      */
     @Override
     public <U> LazySetX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazySetX)super.zip(other);
+
+        return (LazySetX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#zip(java.lang.
+     * Iterable, java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazySetX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazySetX<R>)super.zip(other, zipper);
+
+        return (LazySetX<R>) super.zip(other, zipper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#sliding(int)
      */
     @Override
     public LazySetX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazySetX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazySetX<ListX<T>>) super.sliding(windowSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#sliding(int,
+     * int)
      */
     @Override
     public LazySetX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazySetX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazySetX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#scanLeft(com.
+     * aol.cyclops.Monoid)
      */
     @Override
     public LazySetX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazySetX<T>)super.scanLeft(monoid);
+
+        return (LazySetX<T>) super.scanLeft(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#scanLeft(java.
+     * lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazySetX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazySetX<U>) super.scanLeft(seed, function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#scanRight(com.
+     * aol.cyclops.Monoid)
      */
     @Override
     public LazySetX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazySetX<T>)super.scanRight(monoid);
+
+        return (LazySetX<T>) super.scanRight(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#scanRight(java.
+     * lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazySetX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazySetX<U>)super.scanRight(identity, combiner);
+
+        return (LazySetX<U>) super.scanRight(identity, combiner);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#sorted(java.
+     * util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazySetX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazySetX<T>)super.sorted(function);
+
+        return (LazySetX<T>) super.sorted(function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#plus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#plus(java.lang.
+     * Object)
      */
     @Override
     public LazySetX<T> plus(T e) {
-       
-        return (LazySetX<T>)super.plus(e);
+
+        return (LazySetX<T>) super.plus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#plusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#plusAll(java.
+     * util.Collection)
      */
     @Override
     public LazySetX<T> plusAll(Collection<? extends T> list) {
-       
-        return (LazySetX<T>)super.plusAll(list);
+
+        return (LazySetX<T>) super.plusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#minus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#minus(java.lang
+     * .Object)
      */
     @Override
     public LazySetX<T> minus(Object e) {
-       
-        return (LazySetX<T>)super.minus(e);
+
+        return (LazySetX<T>) super.minus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#minusAll(java.
+     * util.Collection)
      */
     @Override
     public LazySetX<T> minusAll(Collection<?> list) {
-       
-        return (LazySetX<T>)super.minusAll(list);
+
+        return (LazySetX<T>) super.minusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#plusLazy(java.
+     * lang.Object)
      */
     @Override
     public LazySetX<T> plusLazy(T e) {
-       
-        return (LazySetX<T>)super.plusLazy(e);
+
+        return (LazySetX<T>) super.plusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#plusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazySetX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazySetX<T>)super.plusAllLazy(list);
+
+        return (LazySetX<T>) super.plusAllLazy(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#minusLazy(java.
+     * lang.Object)
      */
     @Override
     public LazySetX<T> minusLazy(Object e) {
-       
-        return (LazySetX<T>)super.minusLazy(e);
+
+        return (LazySetX<T>) super.minusLazy(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#minusAllLazy(
+     * java.util.Collection)
      */
     @Override
     public LazySetX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazySetX<T>)super.minusAllLazy(list);
+
+        return (LazySetX<T>) super.minusAllLazy(list);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.SetX#cycle(int)
      */
     @Override
     public LazyListX<T> cycle(int times) {
         return LazyListX.fromPublisher(this.flux()
-                                       .repeat(times));
+                                           .repeat(times));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#cycle(com.aol.
+     * cyclops.Monoid, int)
      */
     @Override
     public LazyListX<T> cycle(Monoid<T> m, int times) {
         return LazyListX.fromPublisher(Fluxes.cycle(flux(), m, times));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#cycleWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return LazyListX.fromPublisher(Fluxes.cycleWhile(flux(),predicate));
+
+        return LazyListX.fromPublisher(Fluxes.cycleWhile(flux(), predicate));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#cycleUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazyListX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return LazyListX.fromPublisher(Fluxes.cycleUntil(flux(),predicate));
+
+        return LazyListX.fromPublisher(Fluxes.cycleUntil(flux(), predicate));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#zip(org.jooq.
+     * lambda.Seq)
      */
     @Override
     public <U> LazySetX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazySetX)super.zip(other);
+
+        return (LazySetX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#zip3(java.util.
+     * stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <S, U> LazySetX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazySetX)super.zip3(second, third);
+
+        return (LazySetX) super.zip3(second, third);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#zip4(java.util.
+     * stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <T2, T3, T4> LazySetX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
             Stream<? extends T4> fourth) {
-       
-        return (LazySetX)super.zip4(second, third, fourth);
+
+        return (LazySetX) super.zip4(second, third, fourth);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#zipWithIndex()
      */
     @Override
     public LazySetX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazySetX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazySetX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.SetX#distinct()
      */
     @Override
     public LazySetX<T> distinct() {
-       
-        return (LazySetX<T>)super.distinct();
+
+        return (LazySetX<T>) super.distinct();
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.SetX#sorted()
      */
     @Override
     public LazySetX<T> sorted() {
-       
-        return (LazySetX<T>)super.sorted();
+
+        return (LazySetX<T>) super.sorted();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#sorted(java.
+     * util.Comparator)
      */
     @Override
     public LazySetX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazySetX<T>)super.sorted(c);
+
+        return (LazySetX<T>) super.sorted(c);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#skipWhile(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazySetX<T>)super.skipWhile(p);
+
+        return (LazySetX<T>) super.skipWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#skipUntil(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazySetX<T>)super.skipUntil(p);
+
+        return (LazySetX<T>) super.skipUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#limitWhile(java
+     * .util.function.Predicate)
      */
     @Override
     public LazySetX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazySetX<T>)super.limitWhile(p);
+
+        return (LazySetX<T>) super.limitWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#limitUntil(java
+     * .util.function.Predicate)
      */
     @Override
     public LazySetX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazySetX<T>)super.limitUntil(p);
+
+        return (LazySetX<T>) super.limitUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#intersperse(
+     * java.lang.Object)
      */
     @Override
     public LazySetX<T> intersperse(T value) {
-       
-        return (LazySetX<T>)super.intersperse(value);
+
+        return (LazySetX<T>) super.intersperse(value);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.SetX#shuffle()
      */
     @Override
     public LazySetX<T> shuffle() {
-       
-        return (LazySetX<T>)super.shuffle();
+
+        return (LazySetX<T>) super.shuffle();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#skipLast(int)
      */
     @Override
     public LazySetX<T> skipLast(int num) {
-       
-        return (LazySetX<T>)super.skipLast(num);
+
+        return (LazySetX<T>) super.skipLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#limitLast(int)
      */
     @Override
     public LazySetX<T> limitLast(int num) {
-       
-        return (LazySetX<T>)super.limitLast(num);
+
+        return (LazySetX<T>) super.limitLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#onEmpty(java.
+     * lang.Object)
      */
     @Override
     public LazySetX<T> onEmpty(T value) {
-       
-        return (LazySetX<T>)super.onEmpty(value);
+
+        return (LazySetX<T>) super.onEmpty(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#onEmptyGet(java
+     * .util.function.Supplier)
      */
     @Override
     public LazySetX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazySetX<T>)super.onEmptyGet(supplier);
+
+        return (LazySetX<T>) super.onEmptyGet(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#onEmptyThrow(
+     * java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazySetX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazySetX<T>)super.onEmptyThrow(supplier);
+
+        return (LazySetX<T>) super.onEmptyThrow(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#shuffle(java.
+     * util.Random)
      */
     @Override
     public LazySetX<T> shuffle(Random random) {
-       
-        return (LazySetX<T>)super.shuffle(random);
+
+        return (LazySetX<T>) super.shuffle(random);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#ofType(java.
+     * lang.Class)
      */
     @Override
     public <U> LazySetX<U> ofType(Class<? extends U> type) {
-       
-        return (LazySetX<U>)super.ofType(type);
+
+        return (LazySetX<U>) super.ofType(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#filterNot(java.
+     * util.function.Predicate)
      */
     @Override
     public LazySetX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazySetX<T>)super.filterNot(fn);
+
+        return (LazySetX<T>) super.filterNot(fn);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.data.collections.extensions.standard.SetX#notNull()
      */
     @Override
     public LazySetX<T> notNull() {
-       
-        return (LazySetX<T>)super.notNull();
+
+        return (LazySetX<T>) super.notNull();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(java.
+     * util.stream.Stream)
      */
     @Override
     public LazySetX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazySetX<T>)(super.removeAll(stream));
+
+        return (LazySetX<T>) (super.removeAll(stream));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(org.
+     * jooq.lambda.Seq)
      */
     @Override
     public LazySetX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazySetX<T>)super.removeAll(stream);
+
+        return (LazySetX<T>) super.removeAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(java.
+     * lang.Iterable)
      */
     @Override
     public LazySetX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazySetX<T>)super.removeAll(it);
+
+        return (LazySetX<T>) super.removeAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#removeAll(java.
+     * lang.Object[])
      */
     @Override
     public LazySetX<T> removeAll(T... values) {
-       
-        return (LazySetX<T>)super.removeAll(values);
+
+        return (LazySetX<T>) super.removeAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(java.
+     * lang.Iterable)
      */
     @Override
     public LazySetX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazySetX<T>)super.retainAll(it);
+
+        return (LazySetX<T>) super.retainAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(java.
+     * util.stream.Stream)
      */
     @Override
     public LazySetX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazySetX<T>)super.retainAll(stream);
+
+        return (LazySetX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(org.
+     * jooq.lambda.Seq)
      */
     @Override
     public LazySetX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazySetX<T>)super.retainAll(stream);
+
+        return (LazySetX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#retainAll(java.
+     * lang.Object[])
      */
     @Override
     public LazySetX<T> retainAll(T... values) {
-       
-        return (LazySetX<T>)super.retainAll(values);
+
+        return (LazySetX<T>) super.retainAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#cast(java.lang.
+     * Class)
      */
     @Override
     public <U> LazySetX<U> cast(Class<? extends U> type) {
-       
-        return (LazySetX<U>)super.cast(type);
+
+        return (LazySetX<U>) super.cast(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#patternMatch(
+     * java.util.function.Function, java.util.function.Supplier)
      */
     @Override
     public <R> LazySetX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazySetX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazySetX<R>) super.patternMatch(case1, otherwise);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#permutations()
      */
     @Override
     public LazySetX<ReactiveSeq<T>> permutations() {
-       
-        return (LazySetX<ReactiveSeq<T>>)super.permutations();
+
+        return (LazySetX<ReactiveSeq<T>>) super.permutations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#combinations(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#combinations(
+     * int)
      */
     @Override
     public LazySetX<ReactiveSeq<T>> combinations(int size) {
-       
-        return (LazySetX<ReactiveSeq<T>>)super.combinations(size);
+
+        return (LazySetX<ReactiveSeq<T>>) super.combinations(size);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#combinations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#combinations()
      */
     @Override
     public LazySetX<ReactiveSeq<T>> combinations() {
-       
-        return (LazySetX<ReactiveSeq<T>>)super.combinations();
+
+        return (LazySetX<ReactiveSeq<T>>) super.combinations();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#grouped(int,
+     * java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazySetX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazySetX<C>)super.grouped(size, supplier);
+
+        return (LazySetX<C>) super.grouped(size, supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#groupedUntil(
+     * java.util.function.Predicate)
      */
     @Override
     public LazySetX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazySetX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazySetX<ListX<T>>) super.groupedUntil(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#groupedWhile(
+     * java.util.function.Predicate)
      */
     @Override
     public LazySetX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazySetX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazySetX<ListX<T>>) super.groupedWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#groupedWhile(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazySetX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazySetX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazySetX<C>) super.groupedWhile(predicate, factory);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#groupedUntil(
+     * java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazySetX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazySetX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazySetX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** SetX methods **/
 
-    /* Makes a defensive copy of this SetX replacing the value at i with the specified element
-     *  (non-Javadoc)
-     * @see com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(int, java.lang.Object)
+    /*
+     * Makes a defensive copy of this SetX replacing the value at i with the
+     * specified element (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(
+     * int, java.lang.Object)
      */
-    public LazySetX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazySetX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#unit(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #unit(java.util.Collection)
      */
     @Override
-    public <R> LazySetX<R> unit(Collection<R> col){
+    public <R> LazySetX<R> unit(Collection<R> col) {
         return LazySetX.fromIterable(col);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
      */
     @Override
-    public  <R> LazySetX<R> unit(R value){
+    public <R> LazySetX<R> unit(R value) {
         return LazySetX.singleton(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#unitIterator(java.util.Iterator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#unitIterator(java.util.Iterator)
      */
     @Override
-    public <R> LazySetX<R> unitIterator(Iterator<R> it){
-        return LazySetX.fromIterable(()->it);
+    public <R> LazySetX<R> unitIterator(Iterator<R> it) {
+        return LazySetX.fromIterable(() -> it);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazySetX<T> plusInOrder(T e) {
-        
-        return (LazySetX<T>)super.plusInOrder(e);
+
+        return (LazySetX<T>) super.plusInOrder(e);
     }
-    
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <T1> LazySetX<T1> from(Collection<T1> c) {
-        if(c instanceof List)
-            return new LazySetX<T1>((Set)c,(Collector)collector);
-      return new LazySetX<T1>((Set)c.stream().collect(SetX.defaultCollector()),(Collector)this.collector);
+        if (c instanceof List)
+            return new LazySetX<T1>(
+                                    (Set) c, (Collector) collector);
+        return new LazySetX<T1>(
+                                (Set) c.stream()
+                                       .collect(SetX.defaultCollector()),
+                                (Collector) this.collector);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazySetX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazySetX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazySetX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazySetX<T> peek(Consumer<? super T> c) {
-        
-        return (LazySetX)super.peek(c);
+
+        return (LazySetX) super.peek(c);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazySetX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazySetX<R>)super.zip(other, zipper);
+    public <U, R> LazySetX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazySetX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazySetX<R> zip(Stream<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazySetX<R>)super.zip(other, zipper);
+    public <U, R> LazySetX<R> zip(Stream<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazySetX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazySetX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazySetX)super.zip(other);
+
+        return (LazySetX) super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazySetX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazySetX<R>)super.zip(fn, publisher);
+
+        return (LazySetX<R>) super.zip(fn, publisher);
     }
- 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#fromStream(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#fromStream(java
+     * .util.stream.Stream)
      */
     @Override
     public <X> LazySetX<X> fromStream(Stream<X> stream) {
-        Set<X> list = (Set<X>) stream.collect((Collector)getCollector());
-        return new LazySetX<X>(list, (Collector)getCollector());
+        Set<X> list = (Set<X>) stream.collect((Collector) getCollector());
+        return new LazySetX<X>(
+                               list, (Collector) getCollector());
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SetX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SetX#onEmptySwitch(
+     * java.util.function.Supplier)
      */
     @Override
     public LazySetX<T> onEmptySwitch(Supplier<? extends Set<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
     }
-    
-   
-   
-    
+
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySortedSetX.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySortedSetX.java
index fc6925ec..f2fcb6cd 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySortedSetX.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/collections/extensions/standard/LazySortedSetX.java
@@ -74,21 +74,22 @@
  *
  * @param <T> the type of elements held in this collection
  */
-public class LazySortedSetX<T> extends AbstractFluentCollectionX<T> implements SortedSetX<T> {
-    private final  LazyFluentCollection<T,SortedSet<T>> lazy;
+public class LazySortedSetX<T> extends AbstractFluentCollectionX<T>implements SortedSetX<T> {
+    private final LazyFluentCollection<T, SortedSet<T>> lazy;
     @Getter
-    private final Collector<T,?,SortedSet<T>> collector;
-    
-    
+    private final Collector<T, ?, SortedSet<T>> collector;
+
     /**
      * Create a LazySortedSetX from a Stream
      * 
      * @param stream to construct a LazySortedSetX from
      * @return LazySortedSetX
      */
-    public static <T> LazySortedSetX<T> fromStreamS(Stream<T> stream){
-        return new LazySortedSetX<T>(Flux.from(ReactiveSeq.fromStream(stream)));
+    public static <T> LazySortedSetX<T> fromStreamS(Stream<T> stream) {
+        return new LazySortedSetX<T>(
+                                     Flux.from(ReactiveSeq.fromStream(stream)));
     }
+
     /**
      * Create a LazySortedSetX that contains the Integers between start and end
      * 
@@ -144,7 +145,7 @@ public static <U, T> LazySortedSetX<T> unfold(U seed, Function<? super U, Option
     public static <T> LazySortedSetX<T> generate(long limit, Supplier<T> s) {
 
         return fromStreamS(ReactiveSeq.generate(s)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
     /**
@@ -157,10 +158,9 @@ public static <T> LazySortedSetX<T> generate(long limit, Supplier<T> s) {
      */
     public static <T> LazySortedSetX<T> iterate(long limit, final T seed, final UnaryOperator<T> f) {
         return fromStreamS(ReactiveSeq.iterate(seed, f)
-                          .limit(limit));
+                                      .limit(limit));
     }
 
-
     /**
      * @return A collector that generates a LazySortedSetX
      */
@@ -168,14 +168,13 @@ public static <T> LazySortedSetX<T> iterate(long limit, final T seed, final Unar
         return Collectors.toCollection(() -> LazySortedSetX.of());
     }
 
-   
-
     /**
      * @return An empty LazySortedSetX
      */
     public static <T> LazySortedSetX<T> empty() {
-        return fromIterable((List<T>) ListX.<T>defaultCollector().supplier()
-                                                        .get());
+        return fromIterable((List<T>) ListX.<T> defaultCollector()
+                                           .supplier()
+                                           .get());
     }
 
     /**
@@ -196,8 +195,9 @@ public static <T> LazySortedSetX<T> empty() {
      */
     @SafeVarargs
     public static <T> LazySortedSetX<T> of(T... values) {
-        List<T> res = (List<T>) ListX.<T>defaultCollector().supplier()
-                                                  .get();
+        List<T> res = (List<T>) ListX.<T> defaultCollector()
+                                     .supplier()
+                                     .get();
         for (T v : values)
             res.add(v);
         return fromIterable(res);
@@ -238,7 +238,7 @@ public static <T> LazySortedSetX<T> fromPublisher(Publisher<? extends T> publish
      * @return LazySortedSetX from Iterable
      */
     public static <T> LazySortedSetX<T> fromIterable(Iterable<T> it) {
-        return fromIterable(SortedSetX.<T>defaultCollector(), it);
+        return fromIterable(SortedSetX.<T> defaultCollector(), it);
     }
 
     /**
@@ -251,39 +251,51 @@ public static <T> LazySortedSetX<T> fromIterable(Iterable<T> it) {
     public static <T> LazySortedSetX<T> fromIterable(Collector<T, ?, SortedSet<T>> collector, Iterable<T> it) {
         if (it instanceof LazySortedSetX)
             return (LazySortedSetX<T>) it;
-       
+
         if (it instanceof SortedSet)
             return new LazySortedSetX<T>(
-                                    (SortedSet<T>) it, collector);
+                                         (SortedSet<T>) it, collector);
         return new LazySortedSetX<T>(
-                                Flux.fromIterable(it),
-                                collector);
+                                     Flux.fromIterable(it), collector);
     }
-    private LazySortedSetX(SortedSet<T> list,Collector<T,?,SortedSet<T>> collector){
-        this.lazy = new LazyCollection<>(list,null,collector);
-        this.collector=  collector;
+
+    private LazySortedSetX(SortedSet<T> list, Collector<T, ?, SortedSet<T>> collector) {
+        this.lazy = new LazyCollection<>(
+                                         list, null, collector);
+        this.collector = collector;
     }
-    
-    private LazySortedSetX(SortedSet<T> list){
+
+    private LazySortedSetX(SortedSet<T> list) {
         this.collector = SortedSetX.defaultCollector();
-        this.lazy = new LazyCollection<T,SortedSet<T>>(list,null,collector);
+        this.lazy = new LazyCollection<T, SortedSet<T>>(
+                                                        list, null, collector);
     }
-    private LazySortedSetX(Flux<T> stream,Collector<T,?,SortedSet<T>> collector){
-        
+
+    private LazySortedSetX(Flux<T> stream, Collector<T, ?, SortedSet<T>> collector) {
+
         this.collector = collector;
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazySortedSetX(Flux<T> stream){
-        
+
+    private LazySortedSetX(Flux<T> stream) {
+
         this.collector = SortedSetX.defaultCollector();
-        this.lazy = new LazyCollection<>(null,stream,collector);
+        this.lazy = new LazyCollection<>(
+                                         null, stream, collector);
     }
-    private LazySortedSetX(){
+
+    private LazySortedSetX() {
         this.collector = SortedSetX.defaultCollector();
-        this.lazy = new LazyCollection<>((SortedSet)this.collector.supplier().get(),null,collector);
+        this.lazy = new LazyCollection<>(
+                                         (SortedSet) this.collector.supplier()
+                                                                   .get(),
+                                         null, collector);
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
      */
     @Override
@@ -291,7 +303,9 @@ public void forEach(Consumer<? super T> action) {
         getSortedSet().forEach(action);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -299,7 +313,9 @@ public Iterator<T> iterator() {
         return getSortedSet().iterator();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#size()
      */
     @Override
@@ -307,7 +323,9 @@ public int size() {
         return getSortedSet().size();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#contains(java.lang.Object)
      */
     @Override
@@ -315,7 +333,9 @@ public boolean contains(Object e) {
         return getSortedSet().contains(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
@@ -323,9 +343,9 @@ public boolean equals(Object o) {
         return getSortedSet().equals(o);
     }
 
-
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#isEmpty()
      */
     @Override
@@ -333,7 +353,9 @@ public boolean isEmpty() {
         return getSortedSet().isEmpty();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -341,7 +363,9 @@ public int hashCode() {
         return getSortedSet().hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray()
      */
     @Override
@@ -349,7 +373,9 @@ public Object[] toArray() {
         return getSortedSet().toArray();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeAll(java.util.Collection)
      */
     @Override
@@ -357,7 +383,9 @@ public boolean removeAll(Collection<?> c) {
         return getSortedSet().removeAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#toArray(java.lang.Object[])
      */
     @Override
@@ -365,7 +393,9 @@ public <T> T[] toArray(T[] a) {
         return getSortedSet().toArray(a);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#add(java.lang.Object)
      */
     @Override
@@ -373,7 +403,9 @@ public boolean add(T e) {
         return getSortedSet().add(e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#remove(java.lang.Object)
      */
     @Override
@@ -381,7 +413,9 @@ public boolean remove(Object o) {
         return getSortedSet().remove(o);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#containsAll(java.util.Collection)
      */
     @Override
@@ -389,7 +423,9 @@ public boolean containsAll(Collection<?> c) {
         return getSortedSet().containsAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#addAll(java.util.Collection)
      */
     @Override
@@ -397,7 +433,9 @@ public boolean addAll(Collection<? extends T> c) {
         return getSortedSet().addAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#retainAll(java.util.Collection)
      */
     @Override
@@ -405,7 +443,9 @@ public boolean retainAll(Collection<?> c) {
         return getSortedSet().retainAll(c);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#clear()
      */
     @Override
@@ -413,8 +453,9 @@ public void clear() {
         getSortedSet().clear();
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -422,7 +463,9 @@ public String toString() {
         return getSortedSet().toString();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#collect(java.util.stream.Collector)
      */
     @Override
@@ -430,786 +473,1207 @@ public <R, A> R collect(Collector<? super T, A, R> collector) {
         return stream().collect(collector);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see org.jooq.lambda.Collectable#count()
      */
     @Override
     public long count() {
         return this.size();
     }
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#removeIf(java.util.function.Predicate)
      */
     @Override
-    public  boolean removeIf(Predicate<? super T> filter) {
+    public boolean removeIf(Predicate<? super T> filter) {
         return getSortedSet().removeIf(filter);
     }
-   
-    
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.Collection#parallelStream()
      */
     @Override
-    public  Stream<T> parallelStream() {
+    public Stream<T> parallelStream() {
         return getSortedSet().parallelStream();
     }
-    
-    
-  
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#spliterator()
      */
     @Override
     public Spliterator<T> spliterator() {
         return getSortedSet().spliterator();
     }
-    
+
     private SortedSet<T> getSortedSet() {
         return lazy.get();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#stream(reactor.core.publisher.Flux)
      */
     @Override
-    public <X> LazySortedSetX<X> stream(Flux<X> stream){
-        return new LazySortedSetX<X>(stream);
+    public <X> LazySortedSetX<X> stream(Flux<X> stream) {
+        return new LazySortedSetX<X>(
+                                     stream);
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.persistent.PBagX#stream()
      */
     @Override
     public ReactiveSeq<T> stream() {
-        return ReactiveSeq.fromStream(lazy.get().stream());
+        return ReactiveSeq.fromStream(lazy.get()
+                                          .stream());
     }
+
     @Override
     public Flux<T> flux() {
         return lazy.flux();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#combine(
+     * java.util.function.BiPredicate, java.util.function.BinaryOperator)
      */
     @Override
     public LazySortedSetX<T> combine(BiPredicate<? super T, ? super T> predicate, BinaryOperator<T> op) {
-       
-        return (LazySortedSetX<T>)super.combine(predicate, op);
+
+        return (LazySortedSetX<T>) super.combine(predicate, op);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#reverse()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#reverse()
      */
     @Override
     public LazySortedSetX<T> reverse() {
-       
-        return(LazySortedSetX<T>)super.reverse();
+
+        return (LazySortedSetX<T>) super.reverse();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#filter(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#filter(
+     * java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> filter(Predicate<? super T> pred) {
-       
-        return (LazySortedSetX<T>)super.filter(pred);
+
+        return (LazySortedSetX<T>) super.filter(pred);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#map(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#map(java.
+     * util.function.Function)
      */
     @Override
     public <R> LazySortedSetX<R> map(Function<? super T, ? extends R> mapper) {
-       
-        return (LazySortedSetX<R>)super.map(mapper);
+
+        return (LazySortedSetX<R>) super.map(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#flatMap(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#flatMap(
+     * java.util.function.Function)
      */
     @Override
     public <R> LazySortedSetX<R> flatMap(Function<? super T, ? extends Iterable<? extends R>> mapper) {
-       return (LazySortedSetX<R>)super.flatMap(mapper);
+        return (LazySortedSetX<R>) super.flatMap(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#limit(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#limit(
+     * long)
      */
     @Override
     public LazySortedSetX<T> limit(long num) {
-       return (LazySortedSetX<T>)super.limit(num);
+        return (LazySortedSetX<T>) super.limit(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skip(long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skip(
+     * long)
      */
     @Override
     public LazySortedSetX<T> skip(long num) {
-       return (LazySortedSetX<T>)super.skip(num);
+        return (LazySortedSetX<T>) super.skip(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#takeRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#takeRight
+     * (int)
      */
     @Override
     public LazySortedSetX<T> takeRight(int num) {
-       return (LazySortedSetX<T>)super.takeRight(num);
+        return (LazySortedSetX<T>) super.takeRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#dropRight(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#dropRight
+     * (int)
      */
     @Override
     public LazySortedSetX<T> dropRight(int num) {
-       return (LazySortedSetX<T>)super.dropRight(num);
+        return (LazySortedSetX<T>) super.dropRight(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#takeWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#takeWhile
+     * (java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> takeWhile(Predicate<? super T> p) {
-       return (LazySortedSetX<T>)super.takeWhile(p);
+        return (LazySortedSetX<T>) super.takeWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#dropWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#dropWhile
+     * (java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> dropWhile(Predicate<? super T> p) {
-       return (LazySortedSetX<T>)super.dropWhile(p);
+        return (LazySortedSetX<T>) super.dropWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#takeUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#takeUntil
+     * (java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> takeUntil(Predicate<? super T> p) {
-       return (LazySortedSetX<T>)super.takeUntil(p);
+        return (LazySortedSetX<T>) super.takeUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#dropUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#dropUntil
+     * (java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> dropUntil(Predicate<? super T> p) {
-       return(LazySortedSetX<T>)super.dropUntil(p);
+        return (LazySortedSetX<T>) super.dropUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#trampoline(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * trampoline(java.util.function.Function)
      */
     @Override
     public <R> LazySortedSetX<R> trampoline(Function<? super T, ? extends Trampoline<? extends R>> mapper) {
-       return (LazySortedSetX<R>)super.trampoline(mapper);
+        return (LazySortedSetX<R>) super.trampoline(mapper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#slice(long, long)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#slice(
+     * long, long)
      */
     @Override
     public LazySortedSetX<T> slice(long from, long to) {
-       return (LazySortedSetX<T>)super.slice(from, to);
+        return (LazySortedSetX<T>) super.slice(from, to);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#grouped(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#grouped(
+     * int)
      */
     @Override
     public LazySortedSetX<ListX<T>> grouped(int groupSize) {
-       
-        return (LazySortedSetX<ListX<T>>)super.grouped(groupSize);
+
+        return (LazySortedSetX<ListX<T>>) super.grouped(groupSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#grouped(java.util.function.Function, java.util.stream.Collector)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#grouped(
+     * java.util.function.Function, java.util.stream.Collector)
      */
     @Override
     public <K, A, D> LazySortedSetX<Tuple2<K, D>> grouped(Function<? super T, ? extends K> classifier,
             Collector<? super T, A, D> downstream) {
-       
-        return (LazySortedSetX)super.grouped(classifier, downstream);
+
+        return (LazySortedSetX) super.grouped(classifier, downstream);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip(java.
+     * lang.Iterable)
      */
     @Override
     public <U> LazySortedSetX<Tuple2<T, U>> zip(Iterable<? extends U> other) {
-       
-        return (LazySortedSetX)super.zip(other);
+
+        return (LazySortedSetX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip(java.lang.Iterable, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip(java.
+     * lang.Iterable, java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazySortedSetX<R> zip(Iterable<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
-       
-        return (LazySortedSetX<R>)super.zip(other, zipper);
+    public <U, R> LazySortedSetX<R> zip(Iterable<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazySortedSetX<R>) super.zip(other, zipper);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sliding(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sliding(
+     * int)
      */
     @Override
     public LazySortedSetX<ListX<T>> sliding(int windowSize) {
-       
-        return (LazySortedSetX<ListX<T>>)super.sliding(windowSize);
+
+        return (LazySortedSetX<ListX<T>>) super.sliding(windowSize);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sliding(int, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sliding(
+     * int, int)
      */
     @Override
     public LazySortedSetX<ListX<T>> sliding(int windowSize, int increment) {
-       
-        return (LazySortedSetX<ListX<T>>)super.sliding(windowSize, increment);
+
+        return (LazySortedSetX<ListX<T>>) super.sliding(windowSize, increment);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanLeft(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanLeft(
+     * com.aol.cyclops.Monoid)
      */
     @Override
     public LazySortedSetX<T> scanLeft(Monoid<T> monoid) {
-       
-        return (LazySortedSetX<T>)super.scanLeft(monoid);
+
+        return (LazySortedSetX<T>) super.scanLeft(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanLeft(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanLeft(
+     * java.lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazySortedSetX<U> scanLeft(U seed, BiFunction<? super U, ? super T, ? extends U> function) {
-       
+
         return (LazySortedSetX<U>) super.scanLeft(seed, function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanRight(com.aol.cyclops.Monoid)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanRight
+     * (com.aol.cyclops.Monoid)
      */
     @Override
     public LazySortedSetX<T> scanRight(Monoid<T> monoid) {
-       
-        return (LazySortedSetX<T>)super.scanRight(monoid);
+
+        return (LazySortedSetX<T>) super.scanRight(monoid);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanRight(java.lang.Object, java.util.function.BiFunction)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#scanRight
+     * (java.lang.Object, java.util.function.BiFunction)
      */
     @Override
     public <U> LazySortedSetX<U> scanRight(U identity, BiFunction<? super T, ? super U, ? extends U> combiner) {
-       
-        return (LazySortedSetX<U>)super.scanRight(identity, combiner);
+
+        return (LazySortedSetX<U>) super.scanRight(identity, combiner);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sorted(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sorted(
+     * java.util.function.Function)
      */
     @Override
     public <U extends Comparable<? super U>> LazySortedSetX<T> sorted(Function<? super T, ? extends U> function) {
-       
-        return (LazySortedSetX<T>)super.sorted(function);
+
+        return (LazySortedSetX<T>) super.sorted(function);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#plus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#plus(java
+     * .lang.Object)
      */
     @Override
     public LazySortedSetX<T> plus(T e) {
-       
-        return (LazySortedSetX<T>)super.plus(e);
+
+        return (LazySortedSetX<T>) super.plus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#plusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#plusAll(
+     * java.util.Collection)
      */
     @Override
     public LazySortedSetX<T> plusAll(Collection<? extends T> list) {
-       
-        return (LazySortedSetX<T>)super.plusAll(list);
+
+        return (LazySortedSetX<T>) super.plusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#minus(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#minus(
+     * java.lang.Object)
      */
     @Override
     public LazySortedSetX<T> minus(Object e) {
-       
-        return (LazySortedSetX<T>)super.minus(e);
+
+        return (LazySortedSetX<T>) super.minus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#minusAll(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#minusAll(
+     * java.util.Collection)
      */
     @Override
     public LazySortedSetX<T> minusAll(Collection<?> list) {
-       
-        return (LazySortedSetX<T>)super.minusAll(list);
+
+        return (LazySortedSetX<T>) super.minusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#plusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#plusLazy(
+     * java.lang.Object)
      */
     @Override
     public LazySortedSetX<T> plusLazy(T e) {
-       
-        return (LazySortedSetX<T>)super.plus(e);
+
+        return (LazySortedSetX<T>) super.plus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#plusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * plusAllLazy(java.util.Collection)
      */
     @Override
     public LazySortedSetX<T> plusAllLazy(Collection<? extends T> list) {
-       
-        return (LazySortedSetX<T>)super.plusAll(list);
+
+        return (LazySortedSetX<T>) super.plusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#minusLazy(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#minusLazy
+     * (java.lang.Object)
      */
     @Override
     public LazySortedSetX<T> minusLazy(Object e) {
-       
-        return (LazySortedSetX<T>)super.minus(e);
+
+        return (LazySortedSetX<T>) super.minus(e);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#minusAllLazy(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * minusAllLazy(java.util.Collection)
      */
     @Override
     public LazySortedSetX<T> minusAllLazy(Collection<?> list) {
-       
-        return (LazySortedSetX<T>)super.minusAll(list);
+
+        return (LazySortedSetX<T>) super.minusAll(list);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cycle(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cycle(
+     * int)
      */
     @Override
     public LazyListX<T> cycle(int times) {
         return LazyListX.fromPublisher(this.flux()
-                                       .repeat(times));
+                                           .repeat(times));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cycle(com.aol.cyclops.Monoid, int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cycle(com
+     * .aol.cyclops.Monoid, int)
      */
     @Override
     public LazyListX<T> cycle(Monoid<T> m, int times) {
         return LazyListX.fromPublisher(Fluxes.cycle(flux(), m, times));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cycleWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * cycleWhile(java.util.function.Predicate)
      */
     @Override
     public LazyListX<T> cycleWhile(Predicate<? super T> predicate) {
-       
-        return LazyListX.fromPublisher(Fluxes.cycleWhile(flux(),predicate));
+
+        return LazyListX.fromPublisher(Fluxes.cycleWhile(flux(), predicate));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cycleUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * cycleUntil(java.util.function.Predicate)
      */
     @Override
     public LazyListX<T> cycleUntil(Predicate<? super T> predicate) {
-       
-        return LazyListX.fromPublisher(Fluxes.cycleUntil(flux(),predicate));
+
+        return LazyListX.fromPublisher(Fluxes.cycleUntil(flux(), predicate));
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip(org.
+     * jooq.lambda.Seq)
      */
     @Override
     public <U> LazySortedSetX<Tuple2<T, U>> zip(Seq<? extends U> other) {
-       
-        return (LazySortedSetX)super.zip(other);
+
+        return (LazySortedSetX) super.zip(other);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip3(java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip3(java
+     * .util.stream.Stream, java.util.stream.Stream)
      */
     @Override
     public <S, U> LazySortedSetX<Tuple3<T, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
-       
-        return (LazySortedSetX)super.zip3(second, third);
+
+        return (LazySortedSetX) super.zip3(second, third);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zip4(java
+     * .util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
-    public <T2, T3, T4> LazySortedSetX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
-            Stream<? extends T4> fourth) {
-       
-        return (LazySortedSetX)super.zip4(second, third, fourth);
+    public <T2, T3, T4> LazySortedSetX<Tuple4<T, T2, T3, T4>> zip4(Stream<? extends T2> second,
+            Stream<? extends T3> third, Stream<? extends T4> fourth) {
+
+        return (LazySortedSetX) super.zip4(second, third, fourth);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#zipWithIndex()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * zipWithIndex()
      */
     @Override
     public LazySortedSetX<Tuple2<T, Long>> zipWithIndex() {
-       
-        return (LazySortedSetX<Tuple2<T, Long>>)super.zipWithIndex();
+
+        return (LazySortedSetX<Tuple2<T, Long>>) super.zipWithIndex();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#distinct()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#distinct(
+     * )
      */
     @Override
     public LazySortedSetX<T> distinct() {
-       
-        return (LazySortedSetX<T>)super.distinct();
+
+        return (LazySortedSetX<T>) super.distinct();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sorted()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sorted()
      */
     @Override
     public LazySortedSetX<T> sorted() {
-       
-        return (LazySortedSetX<T>)super.sorted();
+
+        return (LazySortedSetX<T>) super.sorted();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sorted(java.util.Comparator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#sorted(
+     * java.util.Comparator)
      */
     @Override
     public LazySortedSetX<T> sorted(Comparator<? super T> c) {
-       
-        return (LazySortedSetX<T>)super.sorted(c);
+
+        return (LazySortedSetX<T>) super.sorted(c);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skipWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skipWhile
+     * (java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> skipWhile(Predicate<? super T> p) {
-       
-        return (LazySortedSetX<T>)super.skipWhile(p);
+
+        return (LazySortedSetX<T>) super.skipWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skipUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skipUntil
+     * (java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> skipUntil(Predicate<? super T> p) {
-       
-        return (LazySortedSetX<T>)super.skipUntil(p);
+
+        return (LazySortedSetX<T>) super.skipUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#limitWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * limitWhile(java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> limitWhile(Predicate<? super T> p) {
-       
-        return (LazySortedSetX<T>)super.limitWhile(p);
+
+        return (LazySortedSetX<T>) super.limitWhile(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#limitUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * limitUntil(java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> limitUntil(Predicate<? super T> p) {
-       
-        return (LazySortedSetX<T>)super.limitUntil(p);
+
+        return (LazySortedSetX<T>) super.limitUntil(p);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#intersperse(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * intersperse(java.lang.Object)
      */
     @Override
     public LazySortedSetX<T> intersperse(T value) {
-       
-        return (LazySortedSetX<T>)super.intersperse(value);
+
+        return (LazySortedSetX<T>) super.intersperse(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#shuffle()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#shuffle()
      */
     @Override
     public LazySortedSetX<T> shuffle() {
-       
-        return (LazySortedSetX<T>)super.shuffle();
+
+        return (LazySortedSetX<T>) super.shuffle();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skipLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#skipLast(
+     * int)
      */
     @Override
     public LazySortedSetX<T> skipLast(int num) {
-       
-        return (LazySortedSetX<T>)super.skipLast(num);
+
+        return (LazySortedSetX<T>) super.skipLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#limitLast(int)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#limitLast
+     * (int)
      */
     @Override
     public LazySortedSetX<T> limitLast(int num) {
-       
-        return (LazySortedSetX<T>)super.limitLast(num);
+
+        return (LazySortedSetX<T>) super.limitLast(num);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#onEmpty(java.lang.Object)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#onEmpty(
+     * java.lang.Object)
      */
     @Override
     public LazySortedSetX<T> onEmpty(T value) {
-       
-        return (LazySortedSetX<T>)super.onEmpty(value);
+
+        return (LazySortedSetX<T>) super.onEmpty(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#onEmptyGet(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * onEmptyGet(java.util.function.Supplier)
      */
     @Override
     public LazySortedSetX<T> onEmptyGet(Supplier<? extends T> supplier) {
-       
-        return (LazySortedSetX<T>)super.onEmptyGet(supplier);
+
+        return (LazySortedSetX<T>) super.onEmptyGet(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#onEmptyThrow(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * onEmptyThrow(java.util.function.Supplier)
      */
     @Override
     public <X extends Throwable> LazySortedSetX<T> onEmptyThrow(Supplier<? extends X> supplier) {
-       
-        return (LazySortedSetX<T>)super.onEmptyThrow(supplier);
+
+        return (LazySortedSetX<T>) super.onEmptyThrow(supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#shuffle(java.util.Random)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#shuffle(
+     * java.util.Random)
      */
     @Override
     public LazySortedSetX<T> shuffle(Random random) {
-       
-        return (LazySortedSetX<T>)super.shuffle(random);
+
+        return (LazySortedSetX<T>) super.shuffle(random);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#ofType(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#ofType(
+     * java.lang.Class)
      */
     @Override
     public <U> LazySortedSetX<U> ofType(Class<? extends U> type) {
-       
-        return (LazySortedSetX<U>)super.ofType(type);
+
+        return (LazySortedSetX<U>) super.ofType(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#filterNot(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#filterNot
+     * (java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<T> filterNot(Predicate<? super T> fn) {
-       
-        return (LazySortedSetX<T>)super.filterNot(fn);
+
+        return (LazySortedSetX<T>) super.filterNot(fn);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#notNull()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#notNull()
      */
     @Override
     public LazySortedSetX<T> notNull() {
-       
-        return (LazySortedSetX<T>)super.notNull();
+
+        return (LazySortedSetX<T>) super.notNull();
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll
+     * (java.util.stream.Stream)
      */
     @Override
     public LazySortedSetX<T> removeAll(Stream<? extends T> stream) {
-       
-        return (LazySortedSetX<T>)(super.removeAll(stream));
+
+        return (LazySortedSetX<T>) (super.removeAll(stream));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll
+     * (org.jooq.lambda.Seq)
      */
     @Override
     public LazySortedSetX<T> removeAll(Seq<? extends T> stream) {
-       
-        return (LazySortedSetX<T>)super.removeAll(stream);
+
+        return (LazySortedSetX<T>) super.removeAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll
+     * (java.lang.Iterable)
      */
     @Override
     public LazySortedSetX<T> removeAll(Iterable<? extends T> it) {
-       
-        return (LazySortedSetX<T>)super.removeAll(it);
+
+        return (LazySortedSetX<T>) super.removeAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#removeAll
+     * (java.lang.Object[])
      */
     @Override
     public LazySortedSetX<T> removeAll(T... values) {
-       
-        return (LazySortedSetX<T>)super.removeAll(values);
+
+        return (LazySortedSetX<T>) super.removeAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll(java.lang.Iterable)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll
+     * (java.lang.Iterable)
      */
     @Override
     public LazySortedSetX<T> retainAll(Iterable<? extends T> it) {
-       
-        return (LazySortedSetX<T>)super.retainAll(it);
+
+        return (LazySortedSetX<T>) super.retainAll(it);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll
+     * (java.util.stream.Stream)
      */
     @Override
     public LazySortedSetX<T> retainAll(Stream<? extends T> stream) {
-       
-        return (LazySortedSetX<T>)super.retainAll(stream);
+
+        return (LazySortedSetX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll(org.jooq.lambda.Seq)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll
+     * (org.jooq.lambda.Seq)
      */
     @Override
     public LazySortedSetX<T> retainAll(Seq<? extends T> stream) {
-       
-        return (LazySortedSetX<T>)super.retainAll(stream);
+
+        return (LazySortedSetX<T>) super.retainAll(stream);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll(java.lang.Object[])
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#retainAll
+     * (java.lang.Object[])
      */
     @Override
     public LazySortedSetX<T> retainAll(T... values) {
-       
-        return (LazySortedSetX<T>)super.retainAll(values);
+
+        return (LazySortedSetX<T>) super.retainAll(values);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cast(java.lang.Class)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#cast(java
+     * .lang.Class)
      */
     @Override
     public <U> LazySortedSetX<U> cast(Class<? extends U> type) {
-       
-        return (LazySortedSetX<U>)super.cast(type);
+
+        return (LazySortedSetX<U>) super.cast(type);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#patternMatch(java.util.function.Function, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * patternMatch(java.util.function.Function, java.util.function.Supplier)
      */
     @Override
     public <R> LazySortedSetX<R> patternMatch(Function<CheckValue1<T, R>, CheckValue1<T, R>> case1,
             Supplier<? extends R> otherwise) {
-       
-        return (LazySortedSetX<R>)super.patternMatch(case1, otherwise);
+
+        return (LazySortedSetX<R>) super.patternMatch(case1, otherwise);
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#grouped(int, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.data.collections.extensions.standard.SortedSetX#grouped(
+     * int, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazySortedSetX<C> grouped(int size, Supplier<C> supplier) {
-       
-        return (LazySortedSetX<C>)super.grouped(size, supplier);
+
+        return (LazySortedSetX<C>) super.grouped(size, supplier);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#groupedUntil(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * groupedUntil(java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<ListX<T>> groupedUntil(Predicate<? super T> predicate) {
-       
-        return (LazySortedSetX<ListX<T>>)super.groupedUntil(predicate);
+
+        return (LazySortedSetX<ListX<T>>) super.groupedUntil(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#groupedWhile(java.util.function.Predicate)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * groupedWhile(java.util.function.Predicate)
      */
     @Override
     public LazySortedSetX<ListX<T>> groupedWhile(Predicate<? super T> predicate) {
-       
-        return (LazySortedSetX<ListX<T>>)super.groupedWhile(predicate);
+
+        return (LazySortedSetX<ListX<T>>) super.groupedWhile(predicate);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazySortedSetX<C> groupedWhile(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazySortedSetX<C>)super.groupedWhile(predicate, factory);
+
+        return (LazySortedSetX<C>) super.groupedWhile(predicate, factory);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
     public <C extends Collection<? super T>> LazySortedSetX<C> groupedUntil(Predicate<? super T> predicate,
             Supplier<C> factory) {
-        
-        return (LazySortedSetX<C>)super.groupedUntil(predicate, factory);
+
+        return (LazySortedSetX<C>) super.groupedUntil(predicate, factory);
     }
-   
+
     /** SortedSetX methods **/
 
-    /* Makes a defensive copy of this SortedSetX replacing the value at i with the specified element
-     *  (non-Javadoc)
-     * @see com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(int, java.lang.Object)
+    /*
+     * Makes a defensive copy of this SortedSetX replacing the value at i with
+     * the specified element (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.collections.extensions.standard.MutableSequenceX#with(
+     * int, java.lang.Object)
      */
-    public LazySortedSetX<T> with(int i,T element){
-        return stream( Fluxes.insertAt(Fluxes.deleteBetween(flux(),i, i+1),i,element)) ;
+    public LazySortedSetX<T> with(int i, T element) {
+        return stream(Fluxes.insertAt(Fluxes.deleteBetween(flux(), i, i + 1), i, element));
     }
-    
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#unit(java.util.Collection)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #unit(java.util.Collection)
      */
     @Override
-    public <R> LazySortedSetX<R> unit(Collection<R> col){
+    public <R> LazySortedSetX<R> unit(Collection<R> col) {
         return LazySortedSetX.fromIterable(col);
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
      */
     @Override
-    public  <R> LazySortedSetX<R> unit(R value){
+    public <R> LazySortedSetX<R> unit(R value) {
         return LazySortedSetX.singleton(value);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#unitIterator(java.util.Iterator)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#unitIterator(java.util.Iterator)
      */
     @Override
-    public <R> LazySortedSetX<R> unitIterator(Iterator<R> it){
-        return LazySortedSetX.fromIterable(()->it);
+    public <R> LazySortedSetX<R> unitIterator(Iterator<R> it) {
+        return LazySortedSetX.fromIterable(() -> it);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX#plusInOrder(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.collections.extensions.base.LazyFluentCollectionX
+     * #plusInOrder(java.lang.Object)
      */
     @Override
     public LazySortedSetX<T> plusInOrder(T e) {
-        
-        return (LazySortedSetX<T>)super.plusInOrder(e);
+
+        return (LazySortedSetX<T>) super.plusInOrder(e);
     }
-    
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#from(java.util.Collection)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#from(java.util.Collection)
      */
     @Override
     public <T1> LazySortedSetX<T1> from(Collection<T1> c) {
-        if(c instanceof List)
-            return new LazySortedSetX<T1>((SortedSet)c,(Collector)collector);
-      return new LazySortedSetX<T1>((SortedSet)c.stream().collect(SortedSetX.defaultCollector()),(Collector)this.collector);
+        if (c instanceof List)
+            return new LazySortedSetX<T1>(
+                                          (SortedSet) c, (Collector) collector);
+        return new LazySortedSetX<T1>(
+                                      (SortedSet) c.stream()
+                                                   .collect(SortedSetX.defaultCollector()),
+                                      (Collector) this.collector);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#groupedStatefullyUntil(java.util.function.
+     * BiPredicate)
      */
     @Override
     public LazySortedSetX<ListX<T>> groupedStatefullyUntil(BiPredicate<ListX<? super T>, ? super T> predicate) {
-        
-        return (LazySortedSetX<ListX<T>>)super.groupedStatefullyUntil(predicate);
+
+        return (LazySortedSetX<ListX<T>>) super.groupedStatefullyUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#peek(java.util.function.Consumer)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#peek(java.util.function.Consumer)
      */
     @Override
     public LazySortedSetX<T> peek(Consumer<? super T> c) {
-        
-        return (LazySortedSetX)super.peek(c);
+
+        return (LazySortedSetX) super.peek(c);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> LazySortedSetX<R> zip(Seq<? extends U> other,
-            BiFunction<? super T, ? super U, ? extends R> zipper) {
-        
-        return (LazySortedSetX<R>)super.zip(other, zipper);
+    public <U, R> LazySortedSetX<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
+
+        return (LazySortedSetX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
     public <U, R> LazySortedSetX<R> zip(Stream<? extends U> other,
             BiFunction<? super T, ? super U, ? extends R> zipper) {
-      
-        return (LazySortedSetX<R>)super.zip(other, zipper);
+
+        return (LazySortedSetX<R>) super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.stream.Stream)
      */
     @Override
     public <U> LazySortedSetX<Tuple2<T, U>> zip(Stream<? extends U> other) {
-        
-        return (LazySortedSetX)super.zip(other);
+
+        return (LazySortedSetX) super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#zip(java.util.function.BiFunction, org.reactivestreams.Publisher)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#zip(java.util.function.BiFunction,
+     * org.reactivestreams.Publisher)
      */
     @Override
     public <T2, R> LazySortedSetX<R> zip(BiFunction<? super T, ? super T2, ? extends R> fn,
             Publisher<? extends T2> publisher) {
-       
-        return (LazySortedSetX<R>)super.zip(fn, publisher);
+
+        return (LazySortedSetX<R>) super.zip(fn, publisher);
     }
- 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#fromStream(java.util.stream.Stream)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * fromStream(java.util.stream.Stream)
      */
     @Override
     public <X> LazySortedSetX<X> fromStream(Stream<X> stream) {
-        SortedSet<X> list = (SortedSet<X>) stream.collect((Collector)getCollector());
-        return new LazySortedSetX<X>(list, (Collector)getCollector());
+        SortedSet<X> list = (SortedSet<X>) stream.collect((Collector) getCollector());
+        return new LazySortedSetX<X>(
+                                     list, (Collector) getCollector());
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#onEmptySwitch(java.util.function.Supplier)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.data.collections.extensions.standard.SortedSetX#
+     * onEmptySwitch(java.util.function.Supplier)
      */
     @Override
     public LazySortedSetX<T> onEmptySwitch(Supplier<? extends SortedSet<T>> supplier) {
-        return stream(Fluxes.onEmptySwitch(flux(), ()->Flux.fromIterable(supplier.get())));
+        return stream(Fluxes.onEmptySwitch(flux(), () -> Flux.fromIterable(supplier.get())));
     }
-    
+
     /**
      * @return
      * @see java.util.SortedSet#comparator()
@@ -1217,6 +1681,7 @@ public LazySortedSetX<T> onEmptySwitch(Supplier<? extends SortedSet<T>> supplier
     public Comparator<? super T> comparator() {
         return getSortedSet().comparator();
     }
+
     /**
      * @param fromElement
      * @param toElement
@@ -1224,24 +1689,30 @@ public Comparator<? super T> comparator() {
      * @see java.util.SortedSet#subSet(java.lang.Object, java.lang.Object)
      */
     public SortedSetX<T> subSet(T fromElement, T toElement) {
-        return new LazySortedSetX<>(getSortedSet().subSet(fromElement, toElement),this.collector);
+        return new LazySortedSetX<>(
+                                    getSortedSet().subSet(fromElement, toElement), this.collector);
     }
+
     /**
      * @param toElement
      * @return
      * @see java.util.SortedSet#headSet(java.lang.Object)
      */
     public SortedSetX<T> headSet(T toElement) {
-        return new LazySortedSetX<>(getSortedSet().headSet(toElement),this.collector);
+        return new LazySortedSetX<>(
+                                    getSortedSet().headSet(toElement), this.collector);
     }
+
     /**
      * @param fromElement
      * @return
      * @see java.util.SortedSet#tailSet(java.lang.Object)
      */
     public SortedSet<T> tailSet(T fromElement) {
-        return new LazySortedSetX<>(getSortedSet().tailSet(fromElement),this.collector);
+        return new LazySortedSetX<>(
+                                    getSortedSet().tailSet(fromElement), this.collector);
     }
+
     /**
      * @return
      * @see java.util.SortedSet#first()
@@ -1249,6 +1720,7 @@ public SortedSet<T> tailSet(T fromElement) {
     public T first() {
         return getSortedSet().first();
     }
+
     /**
      * @return
      * @see java.util.SortedSet#last()
@@ -1256,36 +1728,56 @@ public T first() {
     public T last() {
         return getSortedSet().last();
     }
-   
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#permutations()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#permutations()
      */
     @Override
     public LazySortedSetX<ReactiveSeq<T>> permutations() {
-        return stream(Flux.from(Streamable.fromPublisher(flux()).permutations().map(s->s.stream())).map(Comparables::comparable));
+        return stream(Flux.from(Streamable.fromPublisher(flux())
+                                          .permutations()
+                                          .map(s -> s.stream()))
+                          .map(Comparables::comparable));
 
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations(int)
      */
     @Override
     public SortedSetX<ReactiveSeq<T>> combinations(int size) {
-        return stream(Flux.from(Streamable.fromPublisher(flux()).combinations(size).map(s->s.stream())).map(Comparables::comparable));
-       
+        return stream(Flux.from(Streamable.fromPublisher(flux())
+                                          .combinations(size)
+                                          .map(s -> s.stream()))
+                          .map(Comparables::comparable));
+
     }
 
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#combinations()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#combinations()
      */
     @Override
-   public SortedSetX<ReactiveSeq<T>> combinations() {
-        return stream(Flux.from(Streamable.fromPublisher(flux()).combinations().map(s->s.stream())).map(Comparables::comparable));
+    public SortedSetX<ReactiveSeq<T>> combinations() {
+        return stream(Flux.from(Streamable.fromPublisher(flux())
+                                          .combinations()
+                                          .map(s -> s.stream()))
+                          .map(Comparables::comparable));
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.collections.extensions.base.AbstractFluentCollectionX#grouped(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.collections.extensions.base.
+     * AbstractFluentCollectionX#grouped(java.util.function.Function)
      */
     @Override
     public <K> LazySortedSetX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? extends K> classifier) {
@@ -1293,6 +1785,7 @@ public <K> LazySortedSetX<Tuple2<K, Seq<T>>> grouped(Function<? super T, ? exten
         Flux f = flux.map(t -> t.map2(Comparables::comparable));
         return (LazySortedSetX) stream(f);
     }
+
     static class Comparables {
 
         static <T, R extends ReactiveSeq<T> & Comparable<T>> R comparable(Seq<T> seq) {
@@ -1308,10 +1801,12 @@ static <T, R extends ReactiveSeq<T> & Comparable<T>> R comparable(ReactiveSeq<T>
                                      .findFirst()
                                      .get();
 
-            return (R) Proxy.newProxyInstance(SortedSetX.class.getClassLoader(), new Class[] { ReactiveSeq.class, Comparable.class },
+            return (R) Proxy.newProxyInstance(SortedSetX.class.getClassLoader(),
+                                              new Class[] { ReactiveSeq.class, Comparable.class },
                                               (proxy, method, args) -> {
                                                   if (compareTo.equals(method))
-                                                      return Objects.compare(System.identityHashCode(seq), System.identityHashCode(args[0]),
+                                                      return Objects.compare(System.identityHashCode(seq),
+                                                                             System.identityHashCode(args[0]),
                                                                              Comparator.naturalOrder());
                                                   else
                                                       return method.invoke(seq, args);
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/comprehenders/MonoTSeqComprehender.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/comprehenders/MonoTSeqComprehender.java
index 842c13c8..fe0abfbd 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/comprehenders/MonoTSeqComprehender.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/comprehenders/MonoTSeqComprehender.java
@@ -53,7 +53,7 @@ public Class getTargetClass() {
 
     @Override
     public MonoTSeq fromIterator(Iterator o) {
-        
+
         return MonoTSeq.of(Monos.fromIterable(() -> o));
     }
 
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/AbstractPushablePublisher.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/AbstractPushablePublisher.java
index fc5f0212..43c04451 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/AbstractPushablePublisher.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/AbstractPushablePublisher.java
@@ -8,10 +8,11 @@
 
 import com.aol.cyclops.data.async.Adapter;
 
-public abstract class AbstractPushablePublisher<T, X extends Adapter<T>, R  extends Publisher<T>> extends Tuple2<X, R> {
+public abstract class AbstractPushablePublisher<T, X extends Adapter<T>, R extends Publisher<T>> extends Tuple2<X, R> {
 
     public AbstractPushablePublisher(X v1, R v2) {
-        super(v1, v2);
+        super(
+              v1, v2);
     }
 
     public X getInput() {
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/MultipleFluxSource.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/MultipleFluxSource.java
index 4610cd9b..18cf3e80 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/MultipleFluxSource.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/MultipleFluxSource.java
@@ -54,6 +54,7 @@ public ReactiveSeq<T> reactiveSeq() {
 
         return topic.stream();
     }
+
     /**
      * Create a pushable Flux
      * 
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableFlux.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableFlux.java
index 789356c3..600ad274 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableFlux.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableFlux.java
@@ -7,11 +7,11 @@
 public class PushableFlux<T> extends AbstractPushablePublisher<T, Queue<T>, Flux<T>> {
 
     public PushableFlux(Queue<T> v1, Flux<T> v2) {
-        super(v1, v2);
+        super(
+              v1, v2);
 
     }
 
     private static final long serialVersionUID = 1L;
 
 }
-
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableMono.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableMono.java
index ac26a54e..ccc63710 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableMono.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/flux/pushable/PushableMono.java
@@ -4,14 +4,14 @@
 
 import reactor.core.publisher.Mono;
 
-public class PushableMono<T> extends AbstractPushablePublisher<T, Queue<T>,Mono<T>> {
+public class PushableMono<T> extends AbstractPushablePublisher<T, Queue<T>, Mono<T>> {
 
     public PushableMono(Queue<T> v1, Mono<T> v2) {
-        super(v1, v2);
+        super(
+              v1, v2);
 
     }
 
     private static final long serialVersionUID = 1L;
 
 }
-
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupBySize.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupBySize.java
index 753c8e67..bd8441b7 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupBySize.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupBySize.java
@@ -31,9 +31,10 @@ public Flux<C> grouped(int groupSize) {
             throw new IllegalArgumentException(
                                                "Batch size must be 1 or more");
         SeqSubscriber<T> sub = SeqSubscriber.subscriber();
-        Iterator<T> it = stream.subscribeWith(sub).iterator();
-        
-        return Flux.fromIterable(()->new Iterator<C>() {
+        Iterator<T> it = stream.subscribeWith(sub)
+                               .iterator();
+
+        return Flux.fromIterable(() -> new Iterator<C>() {
 
             @Override
             public boolean hasNext() {
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupedWhile.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupedWhile.java
index 4620130f..96fe537d 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupedWhile.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/operators/GroupedWhile.java
@@ -1,7 +1,5 @@
 package com.aol.cyclops.reactor.operators;
 
-
-
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.function.Predicate;
@@ -29,9 +27,10 @@ public GroupedWhile(Flux<T> stream, Supplier<C> factory) {
 
     public Flux<C> batchWhile(Predicate<? super T> predicate) {
         SeqSubscriber<T> sub = SeqSubscriber.subscriber();
-        Iterator<T> it = stream.subscribeWith(sub).iterator();
-       
-        return Flux.fromIterable(()->new Iterator<C>() {
+        Iterator<T> it = stream.subscribeWith(sub)
+                               .iterator();
+
+        return Flux.fromIterable(() -> new Iterator<C>() {
             T value = (T) UNSET;
 
             @Override
@@ -62,7 +61,7 @@ public C next() {
             }
 
         })
-                          .filter(l -> l.size() > 0);
+                   .filter(l -> l.size() > 0);
     }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxT.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxT.java
index d186cf3d..172bd338 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxT.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxT.java
@@ -49,7 +49,6 @@
  */
 public interface FluxT<T> extends FoldableTransformerSeq<T> {
 
-   
     /**
      * Create an instance of the same FluxTransformer type from the provided Iterator over raw values.
      * 
@@ -339,7 +338,6 @@ public static <A> FluxTValue<A> fromFuture(CompletableFuture<Flux<A>> future) {
         return FluxTValue.of(AnyM.fromCompletableFuture(future));
     }
 
-    
     /**
      * Create a FluxTValue from an Iterable that contains nested Fluxes
      * <pre>
@@ -511,8 +509,12 @@ default <U, R> FluxT<R> zip(Iterable<? extends U> other, BiFunction<? super T, ?
         return (FluxT<R>) FoldableTransformerSeq.super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.TransformerSeq#zip(org
+     * .jooq.lambda.Seq, java.util.function.BiFunction)
      */
     @Override
     default <U, R> FluxT<R> zip(Seq<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) {
@@ -539,8 +541,12 @@ default <U> FluxT<Tuple2<T, U>> zip(Stream<? extends U> other) {
         return (FluxT) FoldableTransformerSeq.super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#zip(org.jooq.lambda.Seq)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.TransformerSeq#zip(org
+     * .jooq.lambda.Seq)
      */
     @Override
     default <U> FluxT<Tuple2<T, U>> zip(Seq<? extends U> other) {
@@ -548,8 +554,12 @@ default <U> FluxT<Tuple2<T, U>> zip(Seq<? extends U> other) {
         return (FluxT) FoldableTransformerSeq.super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#zip(java.lang.Iterable)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.TransformerSeq#zip(
+     * java.lang.Iterable)
      */
     @Override
     default <U> FluxT<Tuple2<T, U>> zip(Iterable<? extends U> other) {
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTSeq.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTSeq.java
index 583a4c44..406b8a08 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTSeq.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTSeq.java
@@ -45,8 +45,11 @@ private FluxTSeq(final AnyMSeq<? extends Flux<T>> run) {
         this.run = (AnyMSeq) (run);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#isSeqPresent()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * isSeqPresent()
      */
     public boolean isSeqPresent() {
         return !run.isEmpty();
@@ -137,8 +140,12 @@ public <B> FluxTSeq<B> flatMapT(Function<? super T, FluxTSeq<? extends B>> f) {
                                           .<B> flatMap(a -> a)));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.FluxT#flatMap(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.transformer.FluxT#flatMap(java.util.function.
+     * Function)
      */
     public <B> FluxTSeq<B> flatMap(Function<? super T, ? extends Flux<? extends B>> f) {
 
@@ -183,8 +190,6 @@ public static <A> FluxTSeq<A> of(AnyMSeq<? extends Flux<A>> monads) {
                               monads);
     }
 
- 
-
     /*
      * (non-Javadoc)
      * 
@@ -204,8 +209,12 @@ public <T> FluxTSeq<T> unit(T unit) {
         return of(run.unit(Flux.just(unit)));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq#stream()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq
+     * #stream()
      */
     @Override
     public ReactiveSeq<T> stream() {
@@ -214,7 +223,9 @@ public ReactiveSeq<T> stream() {
                   .flatMap(e -> e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.FluxT#flux()
      */
     @Override
@@ -222,7 +233,9 @@ public Flux<T> flux() {
         return Flux.from(stream());
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Iterable#iterator()
      */
     @Override
@@ -230,15 +243,20 @@ public Iterator<T> iterator() {
         return stream().iterator();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.FluxT#unitIterator(java.util.Iterator)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.transformer.FluxT#unitIterator(java.util.
+     * Iterator)
      */
     public <R> FluxTSeq<R> unitIterator(Iterator<R> it) {
         return of(run.unitIterator(it)
                      .map(i -> Flux.just(i)));
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.FluxT#empty()
      */
     @Override
@@ -246,7 +264,9 @@ public <R> FluxT<R> empty() {
         return of(run.empty());
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.anyM.NestedFoldable#nestedFoldables()
      */
     @Override
@@ -255,7 +275,9 @@ public AnyM<? extends IterableFoldable<T>> nestedFoldables() {
 
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.anyM.NestedCollectable#nestedCollectables()
      */
     @Override
@@ -264,8 +286,11 @@ public AnyM<? extends CyclopsCollectable<T>> nestedCollectables() {
 
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#unitAnyM(com.aol.cyclops.control.AnyM)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * unitAnyM(com.aol.cyclops.control.AnyM)
      */
     @Override
     public <T> FluxTSeq<T> unitAnyM(AnyM<Traversable<T>> traversable) {
@@ -273,15 +298,17 @@ public <T> FluxTSeq<T> unitAnyM(AnyM<Traversable<T>> traversable) {
         return of((AnyMSeq) traversable.map(t -> Flux.fromIterable(t)));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#transformerStream()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * transformerStream()
      */
     @Override
     public AnyMSeq<? extends Traversable<T>> transformerStream() {
         return run.map(i -> ReactiveSeq.fromPublisher(i));
     }
 
-
     /*
      * (non-Javadoc)
      * 
@@ -925,7 +952,9 @@ public <U extends Comparable<? super U>> FluxTSeq<T> sorted(Function<? super T,
         return (FluxTSeq) FluxT.super.sorted(function);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -933,7 +962,9 @@ public int hashCode() {
         return run.hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTValue.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTValue.java
index 81d0660e..aa40c5fa 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTValue.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/FluxTValue.java
@@ -38,8 +38,11 @@ public AnyMValue<Flux<T>> unwrap() {
         return run;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#isSeqPresent()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * isSeqPresent()
      */
     @Override
     public boolean isSeqPresent() {
@@ -122,8 +125,12 @@ public <B> FluxTValue<B> flatMapT(Function<? super T, FluxTValue<? extends B>> f
                                           .<B> flatMap(a -> a)));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.FluxT#flatMap(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.transformer.FluxT#flatMap(java.util.function.
+     * Function)
      */
     public <B> FluxTValue<B> flatMap(Function<? super T, ? extends Flux<? extends B>> f) {
 
@@ -137,7 +144,7 @@ public <B> FluxTValue<B> flatMap(Function<? super T, ? extends Flux<? extends B>
      * This allows multiple monad types to add functionality to existing functions and methods
      * 
      * e.g. to add iteration handling (via Stream) and nullhandling (via Optional) to an existing function
-  
+    
      * 
      * 
      * @param fn Function to enhance with functionality from Stream and another monad type
@@ -168,7 +175,6 @@ public static <A> FluxTValue<A> of(AnyMValue<? extends Flux<A>> monads) {
         return new FluxTValue<>(
                                 monads);
     }
-    
 
     /**
      * @return True if Flux is present
@@ -224,8 +230,12 @@ public <T> FluxTValue<T> unit(T unit) {
         return of(run.unit(Flux.just(unit)));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq#stream()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq
+     * #stream()
      */
     @Override
     public ReactiveSeq<T> stream() {
@@ -234,7 +244,9 @@ public ReactiveSeq<T> stream() {
                   .flatMap(e -> e);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.FluxT#flux()
      */
     @Override
@@ -242,7 +254,9 @@ public Flux<T> flux() {
         return Flux.from(stream());
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.FluxT#empty()
      */
     @Override
@@ -250,8 +264,9 @@ public <R> FluxTValue<R> empty() {
         return of(run.empty());
     }
 
-    
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.anyM.NestedFoldable#nestedFoldables()
      */
     @Override
@@ -260,7 +275,9 @@ public AnyM<? extends IterableFoldable<T>> nestedFoldables() {
 
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.anyM.NestedCollectable#nestedCollectables()
      */
     @Override
@@ -269,8 +286,11 @@ public AnyM<? extends CyclopsCollectable<T>> nestedCollectables() {
 
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#unitAnyM(com.aol.cyclops.control.AnyM)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * unitAnyM(com.aol.cyclops.control.AnyM)
      */
     @Override
     public <T> FluxTValue<T> unitAnyM(AnyM<Traversable<T>> traversable) {
@@ -278,15 +298,20 @@ public <T> FluxTValue<T> unitAnyM(AnyM<Traversable<T>> traversable) {
         return of((AnyMValue) traversable.map(t -> Flux.fromIterable(t)));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#transformerStream()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * transformerStream()
      */
     @Override
     public AnyM<? extends Traversable<T>> transformerStream() {
         return run.map(i -> ReactiveSeq.fromPublisher(i));
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -294,7 +319,9 @@ public int hashCode() {
         return run.hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoT.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoT.java
index af702e98..53435c1a 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoT.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoT.java
@@ -1,6 +1,5 @@
 package com.aol.cyclops.reactor.transformer;
 
-
 import java.util.Iterator;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
@@ -31,7 +30,6 @@
 
 import reactor.core.publisher.Mono;
 
-
 /**
  * Monad Transformer for Reactor Mono types.
  * 
@@ -43,8 +41,11 @@
  */
 public interface MonoT<A> extends Unit<A>, Publisher<A>, Functor<A>, Filterable<A>, ToStream<A> {
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Filterable#filter(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.types.Filterable#filter(java.util.function.Predicate)
      */
     MonoT<A> filter(Predicate<? super A> test);
 
@@ -60,7 +61,7 @@ public interface MonoT<A> extends Unit<A>, Publisher<A>, Functor<A>, Filterable<
      * @return Mapped and flattened MonoT
      */
     default <B> MonoT<B> bind(Function<? super A, MonoT<? extends B>> f) {
-        return of(unwrap().bind(mono-> {
+        return of(unwrap().bind(mono -> {
             return f.apply(mono.block())
                     .unwrap()
                     .unwrap();
@@ -128,7 +129,6 @@ public static <A> MonoT<A> of(AnyM<Mono<A>> monads) {
     @Override
     public <B> MonoT<B> map(Function<? super A, ? extends B> f);
 
- 
     /**
      * flatMap operation
      * 
@@ -169,7 +169,8 @@ public static <U, R> Function<MonoT<U>, MonoT<R>> lift(Function<? super U, ? ext
      * @param fn BiFunction to enhance with functionality from CompletableFuture and another monad type
      * @return Function that accepts and returns an CompletableFutureT
      */
-    public static <U1, U2, R> BiFunction<MonoT<U1>, MonoT<U2>, MonoT<R>> lift2(BiFunction<? super U1, ? super U2, ? extends R> fn) {
+    public static <U1, U2, R> BiFunction<MonoT<U1>, MonoT<U2>, MonoT<R>> lift2(
+            BiFunction<? super U1, ? super U2, ? extends R> fn) {
         return (optTu1, optTu2) -> optTu1.bind(input1 -> optTu2.map(input2 -> fn.apply(input1, input2)));
     }
 
@@ -183,6 +184,7 @@ public static <U1, U2, R> BiFunction<MonoT<U1>, MonoT<U2>, MonoT<R>> lift2(BiFun
     public static <A> MonoT<A> fromAnyM(AnyM<A> anyM) {
         return of(anyM.map(Mono::just));
     }
+
     /**
      * Create a MonoT from an AnyMValue by wrapping the element stored in the AnyMValue in a Mono
      * 
@@ -192,6 +194,7 @@ public static <A> MonoT<A> fromAnyM(AnyM<A> anyM) {
     public static <A> MonoTValue<A> fromAnyMValue(AnyMValue<A> anyM) {
         return MonoTValue.fromAnyM(anyM);
     }
+
     /**
      * Create a MonoT from an AnyMSeq by wrapping the elements stored in the AnyMSeq in a Mono
      * 
@@ -201,6 +204,7 @@ public static <A> MonoTValue<A> fromAnyMValue(AnyMValue<A> anyM) {
     public static <A> MonoTSeq<A> fromAnyMSeq(AnyMSeq<A> anyM) {
         return MonoTSeq.fromAnyM(anyM);
     }
+
     /**
      * Create a MonoTSeq from an Iterable that contains nested Monos
      * <pre>
@@ -247,7 +251,9 @@ public static <T> MonoTSeq<T> emptyList() {
         return MonoT.fromIterable(ListX.of());
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Functor#cast(java.lang.Class)
      */
     @Override
@@ -255,23 +261,33 @@ default <U> MonoT<U> cast(Class<? extends U> type) {
         return (MonoT<U>) Functor.super.cast(type);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Functor#trampoline(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.types.Functor#trampoline(java.util.function.Function)
      */
     @Override
     default <R> MonoT<R> trampoline(Function<? super A, ? extends Trampoline<? extends R>> mapper) {
         return (MonoT<R>) Functor.super.trampoline(mapper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Functor#patternMatch(java.util.function.Function, java.util.function.Supplier)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.types.Functor#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
-    default <R> MonoT<R> patternMatch(Function<CheckValue1<A, R>, CheckValue1<A, R>> case1, Supplier<? extends R> otherwise) {
+    default <R> MonoT<R> patternMatch(Function<CheckValue1<A, R>, CheckValue1<A, R>> case1,
+            Supplier<? extends R> otherwise) {
         return (MonoT<R>) Functor.super.patternMatch(case1, otherwise);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Filterable#ofType(java.lang.Class)
      */
     @Override
@@ -280,8 +296,11 @@ default <U> MonoT<U> ofType(Class<? extends U> type) {
         return (MonoT<U>) Filterable.super.ofType(type);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Filterable#filterNot(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.types.Filterable#filterNot(java.util.function.Predicate)
      */
     @Override
     default MonoT<A> filterNot(Predicate<? super A> fn) {
@@ -289,7 +308,9 @@ default MonoT<A> filterNot(Predicate<? super A> fn) {
         return (MonoT<A>) Filterable.super.filterNot(fn);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Filterable#notNull()
      */
     @Override
@@ -298,8 +319,4 @@ default MonoT<A> notNull() {
         return (MonoT<A>) Filterable.super.notNull();
     }
 
-    
-
-   
-
 }
\ No newline at end of file
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTSeq.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTSeq.java
index 02a9c8d2..bc09514a 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTSeq.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTSeq.java
@@ -23,7 +23,6 @@
 import com.aol.cyclops.Monoid;
 import com.aol.cyclops.control.AnyM;
 import com.aol.cyclops.control.ReactiveSeq;
-import com.aol.cyclops.control.monads.transformers.seq.MaybeTSeq;
 import com.aol.cyclops.control.monads.transformers.values.ValueTransformerSeq;
 import com.aol.cyclops.data.collections.extensions.standard.ListX;
 import com.aol.cyclops.types.IterableFoldable;
@@ -36,7 +35,6 @@
 
 import reactor.core.publisher.Mono;
 
-
 /**
  * Monad Transformer for Reactor Monos nested inside Sequential data types
  * 
@@ -44,14 +42,15 @@
  *
  * @param <A> the type of elements held in the nested Monos
  */
-public class MonoTSeq<A>
-        implements MonoT<A>, ValueTransformerSeq<A>, IterableFoldable<A>, ConvertableSequence<A>, CyclopsCollectable<A>, Sequential<A> {
+public class MonoTSeq<A> implements MonoT<A>, ValueTransformerSeq<A>, IterableFoldable<A>, ConvertableSequence<A>,
+        CyclopsCollectable<A>, Sequential<A> {
 
     private final AnyMSeq<Mono<A>> run;
 
     /**
      * @return The wrapped AnyM
      */
+    @Override
     public AnyMSeq<Mono<A>> unwrap() {
         return run;
     }
@@ -60,69 +59,78 @@ private MonoTSeq(final AnyMSeq<Mono<A>> run) {
         this.run = run;
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.ValueTransformerSeq#
+     * unitStream(com.aol.cyclops.control.ReactiveSeq)
+     */
     @Override
-    public <T> MonoTSeq<T> unitStream(ReactiveSeq<T> traversable) {
+    public <T> MonoTSeq<T> unitStream(final ReactiveSeq<T> traversable) {
         return MonoT.fromStream(traversable.map(Mono::just));
 
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * unitAnyM(com.aol.cyclops.control.AnyM)
+     */
     @Override
-    public <T> MonoTSeq<T> unitAnyM(AnyM<Traversable<T>> traversable) {
+    public <T> MonoTSeq<T> unitAnyM(final AnyM<Traversable<T>> traversable) {
 
         return of((AnyMSeq) traversable.map(t -> Mono.from(t)));
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * transformerStream()
+     */
     @Override
     public AnyMSeq<? extends Traversable<A>> transformerStream() {
 
         return run.map(f -> ListX.of(f.block()));
     }
 
-    
-    public MonoTSeq<A> filter(Predicate<? super A> test) {
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.transformer.MonoT#filter(java.util.function.
+     * Predicate)
+     */
+    @Override
+    public MonoTSeq<A> filter(final Predicate<? super A> test) {
         return MonoTSeq.of(run.map(opt -> opt.filter(test)));
     }
 
-    /**
-     * Peek at the current value of the Mono
-     * <pre>
-     * {@code 
-     *    MonoT.of(AnyM.fromStream(Arrays.asMono(10))
-     *             .peek(System.out::println);
-     *             
-     *     //prints 10        
-     * }
-     * </pre>
+    /*
+     * (non-Javadoc)
      * 
-     * @param peek  Consumer to accept current value of Mono
-     * @return MonoT with peek call
+     * @see com.aol.cyclops.reactor.transformer.MonoT#peek(java.util.function.
+     * Consumer)
      */
-    public MonoTSeq<A> peek(Consumer<? super A> peek) {
+    @Override
+    public MonoTSeq<A> peek(final Consumer<? super A> peek) {
         return of(run.peek(future -> future.map(a -> {
             peek.accept(a);
             return a;
         })));
     }
 
-    /**
-     * Map the wrapped Mono
-     * 
-     * <pre>
-     * {@code 
-     *  MonoT.of(AnyM.fromStream(Arrays.asMono(10))
-     *             .map(t->t=t+1);
-     *  
-     *  
-     *  //MonoT<AnyMSeq<Stream<Mono[11]>>>
-     * }
-     * </pre>
+    /*
+     * (non-Javadoc)
      * 
-     * @param f Mapping function for the wrapped Mono
-     * @return MonoT that applies the map function to the wrapped Mono
+     * @see com.aol.cyclops.reactor.transformer.MonoT#map(java.util.function.
+     * Function)
      */
-    public <B> MonoTSeq<B> map(Function<? super A, ? extends B> f) {
+    @Override
+    public <B> MonoTSeq<B> map(final Function<? super A, ? extends B> f) {
         return new MonoTSeq<B>(
-                                  run.map(o -> o.map(f)));
+                               run.map(o -> o.map(f)));
     }
 
     /**
@@ -140,19 +148,27 @@ public <B> MonoTSeq<B> map(Function<? super A, ? extends B> f) {
      * @return MonoT that applies the flatMap function to the wrapped Mono
      */
 
-    public <B> MonoTSeq<B> flatMapT(Function<? super A, MonoTSeq<B>> f) {
+    public <B> MonoTSeq<B> flatMapT(final Function<? super A, MonoTSeq<B>> f) {
         return of(run.map(future -> Mono.from(future.flatMap(a -> f.apply(a).run.stream()
-                                                                      .toList()
-                                                                      .get(0)))));
+                                                                                .toList()
+                                                                                .get(0)))));
     }
 
-    private static <B> AnyMSeq<Mono<B>> narrow(AnyMSeq<Mono<? extends B>> run) {
+    private static <B> AnyMSeq<Mono<B>> narrow(final AnyMSeq<Mono<? extends B>> run) {
         return (AnyMSeq) run;
     }
 
-    public <B> MonoTSeq<B> flatMap(Function<? super A, ? extends MonadicValue<? extends B>> f) {
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.transformer.MonoT#flatMap(java.util.function.
+     * Function)
+     */
+    @Override
+    public <B> MonoTSeq<B> flatMap(final Function<? super A, ? extends MonadicValue<? extends B>> f) {
 
-        AnyMSeq<Mono<? extends B>> mapped = run.map(o -> Mono.from(o.flatMap(f)));
+        final AnyMSeq<Mono<? extends B>> mapped = run.map(o -> Mono.from(o.flatMap(f)));
         return of(narrow(mapped));
 
     }
@@ -162,31 +178,13 @@ public <B> MonoTSeq<B> flatMap(Function<? super A, ? extends MonadicValue<? exte
      * This allows multiple monad types to add functionality to existing functions and methods
      * 
      * e.g. to add list handling  / iteration (via Mono) and iteration (via Stream) to an existing function
-     * <pre>
-     * {@code 
-        Function<Integer,Integer> add2 = i -> i+2;
-        Function<MonoT<Integer>, MonoT<Integer>> optTAdd2 = MonoT.lift(add2);
-        
-        Stream<Integer> withNulls = Stream.of(1,2,3);
-        AnyMSeq<Integer> stream = AnyM.fromStream(withNulls);
-        AnyMSeq<Mono<Integer>> streamOpt = stream.map(Mono::completedFuture);
-        List<Integer> results = optTAdd2.apply(MonoT.of(streamOpt))
-                                        .unwrap()
-                                        .<Stream<Mono<Integer>>>unwrap()
-                                        .map(Mono::join)
-                                        .collect(Collectors.toList());
-        
-        
-        //Mono.completedFuture(List[3,4]);
-     * 
-     * 
-     * }</pre>
+    
      * 
      * 
      * @param fn Function to enhance with functionality from Mono and another monad type
      * @return Function that accepts and returns an MonoT
      */
-    public static <U, R> Function<MonoTSeq<U>, MonoTSeq<R>> lift(Function<? super U, ? extends R> fn) {
+    public static <U, R> Function<MonoTSeq<U>, MonoTSeq<R>> lift(final Function<? super U, ? extends R> fn) {
         return optTu -> optTu.map(input -> fn.apply(input));
     }
 
@@ -196,31 +194,12 @@ public static <U, R> Function<MonoTSeq<U>, MonoTSeq<R>> lift(Function<? super U,
      * 
      * e.g. to add list handling / iteration (via Mono), iteration (via Stream)  and asynchronous execution (Mono) 
      * to an existing function
-     * 
-     * <pre>
-     * {@code 
-        BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
-        BiFunction<MonoT<Integer>,MonoT<Integer>,MonoT<Integer>> optTAdd2 = MonoT.lift2(add);
-        
-        Stream<Integer> withNulls = Stream.of(1,2,3);
-        AnyMSeq<Integer> stream = AnyM.ofMonad(withNulls);
-        AnyMSeq<Mono<Integer>> streamOpt = stream.map(Mono::completedFuture);
-        
-        Mono<Mono<Integer>> two = Mono.completedFuture(Mono.completedFuture(2));
-        AnyMSeq<Mono<Integer>> future=  AnyM.fromMono(two);
-        List<Integer> results = optTAdd2.apply(MonoT.of(streamOpt),MonoT.of(future))
-                                        .unwrap()
-                                        .<Stream<Mono<Integer>>>unwrap()
-                                        .map(Mono::join)
-                                        .collect(Collectors.toList());
-                                        
-            //Mono.completedFuture(List[3,4,5]);                        
-      }
-      </pre>
+    
      * @param fn BiFunction to enhance with functionality from Mono and another monad type
      * @return Function that accepts and returns an MonoT
      */
-    public static <U1, U2, R> BiFunction<MonoTSeq<U1>, MonoTSeq<U2>, MonoTSeq<R>> lift2(BiFunction<? super U1, ? super U2, ? extends R> fn) {
+    public static <U1, U2, R> BiFunction<MonoTSeq<U1>, MonoTSeq<U2>, MonoTSeq<R>> lift2(
+            final BiFunction<? super U1, ? super U2, ? extends R> fn) {
         return (optTu1, optTu2) -> optTu1.flatMapT(input1 -> optTu2.map(input2 -> fn.apply(input1, input2)));
     }
 
@@ -231,7 +210,7 @@ public static <U1, U2, R> BiFunction<MonoTSeq<U1>, MonoTSeq<U2>, MonoTSeq<R>> li
      * @param anyM AnyM that doesn't contain a monad wrapping an Mono
      * @return MonoT
      */
-    public static <A> MonoTSeq<A> fromAnyM(AnyMSeq<A> anyM) {
+    public static <A> MonoTSeq<A> fromAnyM(final AnyMSeq<A> anyM) {
         return of(anyM.map(Mono::just));
     }
 
@@ -241,12 +220,12 @@ public static <A> MonoTSeq<A> fromAnyM(AnyMSeq<A> anyM) {
      * @param monads AnyM that contains a monad wrapping an Mono
      * @return MonoT
      */
-    public static <A> MonoTSeq<A> of(AnyMSeq<Mono<A>> monads) {
+    public static <A> MonoTSeq<A> of(final AnyMSeq<Mono<A>> monads) {
         return new MonoTSeq<>(
-                                 monads);
+                              monads);
     }
 
-    public static <A> MonoTSeq<A> of(Mono<A> monads) {
+    public static <A> MonoTSeq<A> of(final Mono<A> monads) {
         return MonoT.fromIterable(ListX.of(monads));
     }
 
@@ -255,35 +234,60 @@ public static <A> MonoTSeq<A> of(Mono<A> monads) {
      * 
      * @see java.lang.Object#toString()
      */
+    @Override
     public String toString() {
         return String.format("FutureTSeq[%s]", run);
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.types.stream.ToStream#stream()
+     */
     @Override
     public ReactiveSeq<A> stream() {
         return run.stream()
                   .map(cf -> cf.block());
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.types.stream.ToStream#iterator()
+     */
     @Override
     public Iterator<A> iterator() {
         return stream().iterator();
     }
 
-    public <R> MonoTSeq<R> unitIterator(Iterator<R> it) {
+    public <R> MonoTSeq<R> unitIterator(final Iterator<R> it) {
         return of(run.unitIterator(it)
                      .map(i -> Mono.just(i)));
     }
 
-    public <R> MonoTSeq<R> unit(R value) {
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
+     */
+    @Override
+    public <R> MonoTSeq<R> unit(final R value) {
         return of(run.unit(Mono.just(value)));
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.transformer.MonoT#empty()
+     */
+    @Override
     public <R> MonoTSeq<R> empty() {
         return of(run.unit(Mono.empty()));
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.stream.CyclopsCollectable#collectable()
      */
     @Override
@@ -291,6 +295,13 @@ public Collectable<A> collectable() {
         return stream();
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerSeq#
+     * isSeqPresent()
+     */
+    @Override
     public boolean isSeqPresent() {
         return !run.isEmpty();
     }
@@ -299,117 +310,183 @@ public static <T> MonoTSeq<T> emptyList() {
         return MonoT.fromIterable(ListX.of());
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#combine(java.util.function.BiPredicate, java.util.function.BinaryOperator)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#combine(
+     * java.util.function.BiPredicate, java.util.function.BinaryOperator)
      */
     @Override
-    public MonoTSeq<A> combine(BiPredicate<? super A, ? super A> predicate, BinaryOperator<A> op) {
+    public MonoTSeq<A> combine(final BiPredicate<? super A, ? super A> predicate, final BinaryOperator<A> op) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.combine(predicate, op);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#cycle(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#cycle(int)
      */
     @Override
-    public MonoTSeq<A> cycle(int times) {
+    public MonoTSeq<A> cycle(final int times) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.cycle(times);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#cycle(com.aol.cyclops.Monoid, int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#cycle(com.
+     * aol.cyclops.Monoid, int)
      */
     @Override
-    public MonoTSeq<A> cycle(Monoid<A> m, int times) {
+    public MonoTSeq<A> cycle(final Monoid<A> m, final int times) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.cycle(m, times);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#cycleWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#cycleWhile
+     * (java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> cycleWhile(Predicate<? super A> predicate) {
+    public MonoTSeq<A> cycleWhile(final Predicate<? super A> predicate) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.cycleWhile(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#cycleUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#cycleUntil
+     * (java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> cycleUntil(Predicate<? super A> predicate) {
+    public MonoTSeq<A> cycleUntil(final Predicate<? super A> predicate) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.cycleUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#zip(java.lang.Iterable, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#zip(java.
+     * lang.Iterable, java.util.function.BiFunction)
      */
     @Override
-    public <U, R> MonoTSeq<R> zip(Iterable<? extends U> other, BiFunction<? super A, ? super U, ? extends R> zipper) {
+    public <U, R> MonoTSeq<R> zip(final Iterable<? extends U> other,
+            final BiFunction<? super A, ? super U, ? extends R> zipper) {
 
         return (MonoTSeq<R>) ValueTransformerSeq.super.zip(other, zipper);
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.ValueTransformerSeq#
+     * zip(java.util.stream.Stream, java.util.function.BiFunction)
+     */
     @Override
-    public <U, R> MonoTSeq<R> zip(Stream<? extends U> other, BiFunction<? super A, ? super U, ? extends R> zipper) {
+    public <U, R> MonoTSeq<R> zip(final Stream<? extends U> other,
+            final BiFunction<? super A, ? super U, ? extends R> zipper) {
 
         return (MonoTSeq<R>) ValueTransformerSeq.super.zip(other, zipper);
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.ValueTransformerSeq#
+     * zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+     */
     @Override
-    public <U, R> MonoTSeq<R> zip(Seq<? extends U> other, BiFunction<? super A, ? super U, ? extends R> zipper) {
+    public <U, R> MonoTSeq<R> zip(final Seq<? extends U> other,
+            final BiFunction<? super A, ? super U, ? extends R> zipper) {
 
         return (MonoTSeq<R>) ValueTransformerSeq.super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#zip(java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#zip(java.
+     * util.stream.Stream)
      */
     @Override
-    public <U> MonoTSeq<Tuple2<A, U>> zip(Stream<? extends U> other) {
+    public <U> MonoTSeq<Tuple2<A, U>> zip(final Stream<? extends U> other) {
 
         return (MonoTSeq) ValueTransformerSeq.super.zip(other);
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.ValueTransformerSeq#
+     * zip(java.lang.Iterable)
+     */
     @Override
-    public <U> MonoTSeq<Tuple2<A, U>> zip(Iterable<? extends U> other) {
+    public <U> MonoTSeq<Tuple2<A, U>> zip(final Iterable<? extends U> other) {
 
         return (MonoTSeq) ValueTransformerSeq.super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#zip(org.jooq.lambda.Seq)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#zip(org.
+     * jooq.lambda.Seq)
      */
     @Override
-    public <U> MonoTSeq<Tuple2<A, U>> zip(Seq<? extends U> other) {
+    public <U> MonoTSeq<Tuple2<A, U>> zip(final Seq<? extends U> other) {
 
         return (MonoTSeq) ValueTransformerSeq.super.zip(other);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#zip3(java.util.stream.Stream, java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#zip3(java.
+     * util.stream.Stream, java.util.stream.Stream)
      */
     @Override
-    public <S, U> MonoTSeq<Tuple3<A, S, U>> zip3(Stream<? extends S> second, Stream<? extends U> third) {
+    public <S, U> MonoTSeq<Tuple3<A, S, U>> zip3(final Stream<? extends S> second, final Stream<? extends U> third) {
 
         return (MonoTSeq) ValueTransformerSeq.super.zip3(second, third);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#zip4(java.util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#zip4(java.
+     * util.stream.Stream, java.util.stream.Stream, java.util.stream.Stream)
      */
     @Override
-    public <T2, T3, T4> MonoTSeq<Tuple4<A, T2, T3, T4>> zip4(Stream<? extends T2> second, Stream<? extends T3> third,
-            Stream<? extends T4> fourth) {
+    public <T2, T3, T4> MonoTSeq<Tuple4<A, T2, T3, T4>> zip4(final Stream<? extends T2> second,
+            final Stream<? extends T3> third, final Stream<? extends T4> fourth) {
 
         return (MonoTSeq) ValueTransformerSeq.super.zip4(second, third, fourth);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#zipWithIndex()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * zipWithIndex()
      */
     @Override
     public MonoTSeq<Tuple2<A, Long>> zipWithIndex() {
@@ -417,107 +494,152 @@ public MonoTSeq<Tuple2<A, Long>> zipWithIndex() {
         return (MonoTSeq<Tuple2<A, Long>>) ValueTransformerSeq.super.zipWithIndex();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#sliding(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#sliding(
+     * int)
      */
     @Override
-    public MonoTSeq<ListX<A>> sliding(int windowSize) {
+    public MonoTSeq<ListX<A>> sliding(final int windowSize) {
 
         return (MonoTSeq<ListX<A>>) ValueTransformerSeq.super.sliding(windowSize);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#sliding(int, int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#sliding(
+     * int, int)
      */
     @Override
-    public MonoTSeq<ListX<A>> sliding(int windowSize, int increment) {
+    public MonoTSeq<ListX<A>> sliding(final int windowSize, final int increment) {
 
         return (MonoTSeq<ListX<A>>) ValueTransformerSeq.super.sliding(windowSize, increment);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(int, java.util.function.Supplier)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(
+     * int, java.util.function.Supplier)
      */
     @Override
-    public <C extends Collection<? super A>> MonoTSeq<C> grouped(int size, Supplier<C> supplier) {
+    public <C extends Collection<? super A>> MonoTSeq<C> grouped(final int size, final Supplier<C> supplier) {
 
         return (MonoTSeq<C>) ValueTransformerSeq.super.grouped(size, supplier);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#groupedUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * groupedUntil(java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<ListX<A>> groupedUntil(Predicate<? super A> predicate) {
+    public MonoTSeq<ListX<A>> groupedUntil(final Predicate<? super A> predicate) {
 
         return (MonoTSeq<ListX<A>>) ValueTransformerSeq.super.groupedUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#groupedStatefullyUntil(java.util.function.BiPredicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * groupedStatefullyUntil(java.util.function.BiPredicate)
      */
     @Override
-    public MonoTSeq<ListX<A>> groupedStatefullyUntil(BiPredicate<ListX<? super A>, ? super A> predicate) {
+    public MonoTSeq<ListX<A>> groupedStatefullyUntil(final BiPredicate<ListX<? super A>, ? super A> predicate) {
 
         return (MonoTSeq<ListX<A>>) ValueTransformerSeq.super.groupedStatefullyUntil(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#groupedWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * groupedWhile(java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<ListX<A>> groupedWhile(Predicate<? super A> predicate) {
+    public MonoTSeq<ListX<A>> groupedWhile(final Predicate<? super A> predicate) {
 
         return (MonoTSeq<ListX<A>>) ValueTransformerSeq.super.groupedWhile(predicate);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * groupedWhile(java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
-    public <C extends Collection<? super A>> MonoTSeq<C> groupedWhile(Predicate<? super A> predicate, Supplier<C> factory) {
+    public <C extends Collection<? super A>> MonoTSeq<C> groupedWhile(final Predicate<? super A> predicate,
+            final Supplier<C> factory) {
 
         return (MonoTSeq<C>) ValueTransformerSeq.super.groupedWhile(predicate, factory);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * groupedUntil(java.util.function.Predicate, java.util.function.Supplier)
      */
     @Override
-    public <C extends Collection<? super A>> MonoTSeq<C> groupedUntil(Predicate<? super A> predicate, Supplier<C> factory) {
+    public <C extends Collection<? super A>> MonoTSeq<C> groupedUntil(final Predicate<? super A> predicate,
+            final Supplier<C> factory) {
 
         return (MonoTSeq<C>) ValueTransformerSeq.super.groupedUntil(predicate, factory);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(
+     * int)
      */
     @Override
-    public MonoTSeq<ListX<A>> grouped(int groupSize) {
+    public MonoTSeq<ListX<A>> grouped(final int groupSize) {
 
         return (MonoTSeq<ListX<A>>) ValueTransformerSeq.super.grouped(groupSize);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(java.util.function.Function, java.util.stream.Collector)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(
+     * java.util.function.Function, java.util.stream.Collector)
      */
     @Override
-    public <K, T, D> MonoTSeq<Tuple2<K, D>> grouped(Function<? super A, ? extends K> classifier, Collector<? super A, T, D> downstream) {
+    public <K, T, D> MonoTSeq<Tuple2<K, D>> grouped(final Function<? super A, ? extends K> classifier,
+            final Collector<? super A, T, D> downstream) {
 
         return (MonoTSeq) ValueTransformerSeq.super.grouped(classifier, downstream);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#grouped(
+     * java.util.function.Function)
      */
     @Override
-    public <K> MonoTSeq<Tuple2<K, Seq<A>>> grouped(Function<? super A, ? extends K> classifier) {
+    public <K> MonoTSeq<Tuple2<K, Seq<A>>> grouped(final Function<? super A, ? extends K> classifier) {
 
         return (MonoTSeq) ValueTransformerSeq.super.grouped(classifier);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#distinct()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#distinct()
      */
     @Override
     public MonoTSeq<A> distinct() {
@@ -525,44 +647,63 @@ public MonoTSeq<A> distinct() {
         return (MonoTSeq<A>) ValueTransformerSeq.super.distinct();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#scanLeft(com.aol.cyclops.Monoid)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#scanLeft(
+     * com.aol.cyclops.Monoid)
      */
     @Override
-    public MonoTSeq<A> scanLeft(Monoid<A> monoid) {
+    public MonoTSeq<A> scanLeft(final Monoid<A> monoid) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.scanLeft(monoid);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#scanLeft(java.lang.Object, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#scanLeft(
+     * java.lang.Object, java.util.function.BiFunction)
      */
     @Override
-    public <U> MonoTSeq<U> scanLeft(U seed, BiFunction<? super U, ? super A, ? extends U> function) {
+    public <U> MonoTSeq<U> scanLeft(final U seed, final BiFunction<? super U, ? super A, ? extends U> function) {
 
         return (MonoTSeq<U>) ValueTransformerSeq.super.scanLeft(seed, function);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#scanRight(com.aol.cyclops.Monoid)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#scanRight(
+     * com.aol.cyclops.Monoid)
      */
     @Override
-    public MonoTSeq<A> scanRight(Monoid<A> monoid) {
+    public MonoTSeq<A> scanRight(final Monoid<A> monoid) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.scanRight(monoid);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#scanRight(java.lang.Object, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#scanRight(
+     * java.lang.Object, java.util.function.BiFunction)
      */
     @Override
-    public <U> MonoTSeq<U> scanRight(U identity, BiFunction<? super A, ? super U, ? extends U> combiner) {
+    public <U> MonoTSeq<U> scanRight(final U identity, final BiFunction<? super A, ? super U, ? extends U> combiner) {
 
         return (MonoTSeq<U>) ValueTransformerSeq.super.scanRight(identity, combiner);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#sorted()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#sorted()
      */
     @Override
     public MonoTSeq<A> sorted() {
@@ -570,134 +711,191 @@ public MonoTSeq<A> sorted() {
         return (MonoTSeq<A>) ValueTransformerSeq.super.sorted();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#sorted(java.util.Comparator)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#sorted(
+     * java.util.Comparator)
      */
     @Override
-    public MonoTSeq<A> sorted(Comparator<? super A> c) {
+    public MonoTSeq<A> sorted(final Comparator<? super A> c) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.sorted(c);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#takeWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#takeWhile(
+     * java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> takeWhile(Predicate<? super A> p) {
+    public MonoTSeq<A> takeWhile(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.takeWhile(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#dropWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#dropWhile(
+     * java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> dropWhile(Predicate<? super A> p) {
+    public MonoTSeq<A> dropWhile(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.dropWhile(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#takeUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#takeUntil(
+     * java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> takeUntil(Predicate<? super A> p) {
+    public MonoTSeq<A> takeUntil(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.takeUntil(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#dropUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#dropUntil(
+     * java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> dropUntil(Predicate<? super A> p) {
+    public MonoTSeq<A> dropUntil(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.dropUntil(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#dropRight(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#dropRight(
+     * int)
      */
     @Override
-    public MonoTSeq<A> dropRight(int num) {
+    public MonoTSeq<A> dropRight(final int num) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.dropRight(num);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#takeRight(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#takeRight(
+     * int)
      */
     @Override
-    public MonoTSeq<A> takeRight(int num) {
+    public MonoTSeq<A> takeRight(final int num) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.takeRight(num);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#skip(long)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#skip(long)
      */
     @Override
-    public MonoTSeq<A> skip(long num) {
+    public MonoTSeq<A> skip(final long num) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.skip(num);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#skipWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#skipWhile(
+     * java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> skipWhile(Predicate<? super A> p) {
+    public MonoTSeq<A> skipWhile(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.skipWhile(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#skipUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#skipUntil(
+     * java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> skipUntil(Predicate<? super A> p) {
+    public MonoTSeq<A> skipUntil(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.skipUntil(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#limit(long)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#limit(
+     * long)
      */
     @Override
-    public MonoTSeq<A> limit(long num) {
+    public MonoTSeq<A> limit(final long num) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.limit(num);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#limitWhile(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#limitWhile
+     * (java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> limitWhile(Predicate<? super A> p) {
+    public MonoTSeq<A> limitWhile(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.limitWhile(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#limitUntil(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#limitUntil
+     * (java.util.function.Predicate)
      */
     @Override
-    public MonoTSeq<A> limitUntil(Predicate<? super A> p) {
+    public MonoTSeq<A> limitUntil(final Predicate<? super A> p) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.limitUntil(p);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#intersperse(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * intersperse(java.lang.Object)
      */
     @Override
-    public MonoTSeq<A> intersperse(A value) {
+    public MonoTSeq<A> intersperse(final A value) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.intersperse(value);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#reverse()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#reverse()
      */
     @Override
     public MonoTSeq<A> reverse() {
@@ -705,8 +903,11 @@ public MonoTSeq<A> reverse() {
         return (MonoTSeq<A>) ValueTransformerSeq.super.reverse();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#shuffle()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#shuffle()
      */
     @Override
     public MonoTSeq<A> shuffle() {
@@ -714,84 +915,125 @@ public MonoTSeq<A> shuffle() {
         return (MonoTSeq<A>) ValueTransformerSeq.super.shuffle();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#skipLast(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#skipLast(
+     * int)
      */
     @Override
-    public MonoTSeq<A> skipLast(int num) {
+    public MonoTSeq<A> skipLast(final int num) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.skipLast(num);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#limitLast(int)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#limitLast(
+     * int)
      */
     @Override
-    public MonoTSeq<A> limitLast(int num) {
+    public MonoTSeq<A> limitLast(final int num) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.limitLast(num);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#onEmpty(java.lang.Object)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#onEmpty(
+     * java.lang.Object)
      */
     @Override
-    public MonoTSeq<A> onEmpty(A value) {
+    public MonoTSeq<A> onEmpty(final A value) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.onEmpty(value);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#onEmptyGet(java.util.function.Supplier)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#onEmptyGet
+     * (java.util.function.Supplier)
      */
     @Override
-    public MonoTSeq<A> onEmptyGet(Supplier<? extends A> supplier) {
+    public MonoTSeq<A> onEmptyGet(final Supplier<? extends A> supplier) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.onEmptyGet(supplier);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#onEmptyThrow(java.util.function.Supplier)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#
+     * onEmptyThrow(java.util.function.Supplier)
      */
     @Override
-    public <X extends Throwable> MonoTSeq<A> onEmptyThrow(Supplier<? extends X> supplier) {
+    public <X extends Throwable> MonoTSeq<A> onEmptyThrow(final Supplier<? extends X> supplier) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.onEmptyThrow(supplier);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#shuffle(java.util.Random)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#shuffle(
+     * java.util.Random)
      */
     @Override
-    public MonoTSeq<A> shuffle(Random random) {
+    public MonoTSeq<A> shuffle(final Random random) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.shuffle(random);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#slice(long, long)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#slice(
+     * long, long)
      */
     @Override
-    public MonoTSeq<A> slice(long from, long to) {
+    public MonoTSeq<A> slice(final long from, final long to) {
 
         return (MonoTSeq<A>) ValueTransformerSeq.super.slice(from, to);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.Traversable#sorted(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.Traversable#sorted(
+     * java.util.function.Function)
      */
     @Override
-    public <U extends Comparable<? super U>> MonoTSeq<A> sorted(Function<? super A, ? extends U> function) {
+    public <U extends Comparable<? super U>> MonoTSeq<A> sorted(final Function<? super A, ? extends U> function) {
         return (MonoTSeq) ValueTransformerSeq.super.sorted(function);
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#hashCode()
+     */
     @Override
     public int hashCode() {
         return run.hashCode();
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
     @Override
-    public boolean equals(Object o) {
+    public boolean equals(final Object o) {
         if (o instanceof MonoTSeq) {
             return run.equals(((MonoTSeq) o).run);
         }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTValue.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTValue.java
index c3642b22..a8407b5b 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTValue.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/transformer/MonoTValue.java
@@ -16,7 +16,6 @@
 import org.reactivestreams.Subscriber;
 
 import com.aol.cyclops.Monoid;
-import com.aol.cyclops.control.AnyM;
 import com.aol.cyclops.control.FutureW;
 import com.aol.cyclops.control.Matchable;
 import com.aol.cyclops.control.Matchable.CheckValue1;
@@ -36,15 +35,15 @@
 import lombok.val;
 import reactor.core.publisher.Mono;
 
-
-public class MonoTValue<A> implements MonoT<A>, TransformerValue<A>, MonadicValue1<A>, Supplier<A>, ConvertableFunctor<A>, Filterable<A>,
-        ApplicativeFunctor<A>, Matchable.ValueAndOptionalMatcher<A> {
+public class MonoTValue<A> implements MonoT<A>, TransformerValue<A>, MonadicValue1<A>, Supplier<A>,
+        ConvertableFunctor<A>, Filterable<A>, ApplicativeFunctor<A>, Matchable.ValueAndOptionalMatcher<A> {
 
     private final AnyMValue<Mono<A>> run;
 
     /**
      * @return The wrapped AnyM
      */
+    @Override
     public AnyMValue<Mono<A>> unwrap() {
         return run;
     }
@@ -53,59 +52,82 @@ private MonoTValue(final AnyMValue<Mono<A>> run) {
         this.run = run;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerValue#value()
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.control.monads.transformers.values.TransformerValue#value
+     * ()
      */
+    @Override
     public FutureW<A> value() {
-        return FutureW.of(run.get().toFuture());
+        return FutureW.of(run.get()
+                             .toFuture());
     }
-    /* 
+
+    /*
      * Blocking request that checks for the presence of a result
      * 
      * (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerValue#isPresent()
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerValue#
+     * isPresent()
      */
+    @Override
     public boolean isPresent() {
-        Mono<A> val = run.orElse(Mono.empty());
-        return val.block()!=null;
+        final Mono<A> val = run.orElse(Mono.empty());
+        return val.block() != null;
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.control.monads.transformers.values.TransformerValue#isValuePresent()
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.control.monads.transformers.values.TransformerValue#
+     * isValuePresent()
      */
+    @Override
     public boolean isValuePresent() {
         return !run.isEmpty();
     }
 
-  
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.MonoT#filter(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.transformer.MonoT#filter(java.util.function.
+     * Predicate)
      */
     @Override
-    public MonoTValue<A> filter(Predicate<? super A> test) {  
-       
-        AnyMValue<Mono<A>> x = run.map(opt -> opt.filter(test));
+    public MonoTValue<A> filter(final Predicate<? super A> test) {
+
+        final AnyMValue<Mono<A>> x = run.map(opt -> opt.filter(test));
         return MonoTValue.of(x);
     }
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.MonoT#peek(java.util.function.Consumer)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.transformer.MonoT#peek(java.util.function.
+     * Consumer)
      */
     @Override
-    public MonoTValue<A> peek(Consumer<? super A> peek) {
-        return map(e->{
-           peek.accept(e);
-           return e;
+    public MonoTValue<A> peek(final Consumer<? super A> peek) {
+        return map(e -> {
+            peek.accept(e);
+            return e;
         });
-       
+
     }
 
-  
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.MonoT#map(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.transformer.MonoT#map(java.util.function.
+     * Function)
      */
     @Override
-    public <B> MonoTValue<B> map(Function<? super A, ? extends B> f) {
+    public <B> MonoTValue<B> map(final Function<? super A, ? extends B> f) {
         return new MonoTValue<B>(
-                                    run.map(o -> o.map(f)));
+                                 run.map(o -> o.map(f)));
     }
 
     /*
@@ -116,9 +138,10 @@ public <B> MonoTValue<B> map(Function<? super A, ? extends B> f) {
      * types.Value, java.util.function.BiFunction)
      */
     @Override
-    public <T2, R> MonoTValue<R> combine(Value<? extends T2> app, BiFunction<? super A, ? super T2, ? extends R> fn) {
+    public <T2, R> MonoTValue<R> combine(final Value<? extends T2> app,
+            final BiFunction<? super A, ? super T2, ? extends R> fn) {
         return new MonoTValue<R>(
-                                   run.map(o -> Monos.combine(o,app, fn)));
+                                 run.map(o -> Monos.combine(o, app, fn)));
     }
 
     /*
@@ -128,10 +151,11 @@ public <T2, R> MonoTValue<R> combine(Value<? extends T2> app, BiFunction<? super
      * Iterable, java.util.function.BiFunction)
      */
     @Override
-    public <T2, R> MonoTValue<R> zip(Iterable<? extends T2> app, BiFunction<? super A, ? super T2, ? extends R> fn) {
+    public <T2, R> MonoTValue<R> zip(final Iterable<? extends T2> app,
+            final BiFunction<? super A, ? super T2, ? extends R> fn) {
 
         return new MonoTValue<R>(
-                                   run.map(o -> Monos.zip(o,app, fn)));
+                                 run.map(o -> Monos.zip(o, app, fn)));
     }
 
     /*
@@ -141,52 +165,67 @@ public <T2, R> MonoTValue<R> zip(Iterable<? extends T2> app, BiFunction<? super
      * function.BiFunction, org.reactivestreams.Publisher)
      */
     @Override
-    public <T2, R> MonoTValue<R> zip(BiFunction<? super A, ? super T2, ? extends R> fn, Publisher<? extends T2> app) {
+    public <T2, R> MonoTValue<R> zip(final BiFunction<? super A, ? super T2, ? extends R> fn,
+            final Publisher<? extends T2> app) {
         return new MonoTValue<>(
-                                   run.map(o ->  Monos.zip(o,fn, app)));
+                                run.map(o -> Monos.zip(o, fn, app)));
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Zippable#zip(org.jooq.lambda.Seq, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.types.Zippable#zip(org.jooq.lambda.Seq,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> MonoTValue<R> zip(Seq<? extends U> other, BiFunction<? super A, ? super U, ? extends R> zipper) {
+    public <U, R> MonoTValue<R> zip(final Seq<? extends U> other,
+            final BiFunction<? super A, ? super U, ? extends R> zipper) {
 
         return (MonoTValue<R>) TransformerValue.super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Zippable#zip(java.util.stream.Stream, java.util.function.BiFunction)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.types.Zippable#zip(java.util.stream.Stream,
+     * java.util.function.BiFunction)
      */
     @Override
-    public <U, R> MonoTValue<R> zip(Stream<? extends U> other, BiFunction<? super A, ? super U, ? extends R> zipper) {
+    public <U, R> MonoTValue<R> zip(final Stream<? extends U> other,
+            final BiFunction<? super A, ? super U, ? extends R> zipper) {
 
         return (MonoTValue<R>) TransformerValue.super.zip(other, zipper);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Zippable#zip(java.util.stream.Stream)
      */
     @Override
-    public <U> MonoTValue<Tuple2<A, U>> zip(Stream<? extends U> other) {
+    public <U> MonoTValue<Tuple2<A, U>> zip(final Stream<? extends U> other) {
 
         return (MonoTValue) TransformerValue.super.zip(other);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Zippable#zip(org.jooq.lambda.Seq)
      */
     @Override
-    public <U> MonoTValue<Tuple2<A, U>> zip(Seq<? extends U> other) {
+    public <U> MonoTValue<Tuple2<A, U>> zip(final Seq<? extends U> other) {
 
         return (MonoTValue) TransformerValue.super.zip(other);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Zippable#zip(java.lang.Iterable)
      */
     @Override
-    public <U> MonoTValue<Tuple2<A, U>> zip(Iterable<? extends U> other) {
+    public <U> MonoTValue<Tuple2<A, U>> zip(final Iterable<? extends U> other) {
 
         return (MonoTValue) TransformerValue.super.zip(other);
     }
@@ -205,24 +244,27 @@ public <U> MonoTValue<Tuple2<A, U>> zip(Iterable<? extends U> other) {
      * @param f FlatMap function
      * @return MonoT that applies the flatMap function to the wrapped CompletableFuture
      */
-    public <B> MonoTValue<B> flatMapT(Function<? super A, MonoTValue<B>> f) {
+    public <B> MonoTValue<B> flatMapT(final Function<? super A, MonoTValue<B>> f) {
         return of(run.map(future -> Mono.from(future.flatMap(a -> f.apply(a).run.stream()
-                                                                      .toList()
-                                                                      .get(0)))));
+                                                                                .toList()
+                                                                                .get(0)))));
     }
 
-    private static <B> AnyMValue<Mono<B>> narrow(AnyMValue<Mono<? extends B>> run) {
+    private static <B> AnyMValue<Mono<B>> narrow(final AnyMValue<Mono<? extends B>> run) {
         return (AnyMValue) run;
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.MonoT#flatMap(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.transformer.MonoT#flatMap(java.util.function.
+     * Function)
      */
     @Override
-    public <B> MonoTValue<B> flatMap(Function<? super A, ? extends MonadicValue<? extends B>> f) {
+    public <B> MonoTValue<B> flatMap(final Function<? super A, ? extends MonadicValue<? extends B>> f) {
 
-        
-        AnyMValue<Mono<? extends B>> mapped = run.map(o -> Mono.from(o.flatMap(f)));
+        final AnyMValue<Mono<? extends B>> mapped = run.map(o -> Mono.from(o.flatMap(f)));
         return of(narrow(mapped));
 
     }
@@ -236,7 +278,7 @@ public <B> MonoTValue<B> flatMap(Function<? super A, ? extends MonadicValue<? ex
      * @param fn Function to enhance with functionality from CompletableFuture and another monad type
      * @return Function that accepts and returns an CompletableFutureT
      */
-    public static <U, R> Function<MonoTValue<U>, MonoTValue<R>> lift(Function<? super U, ? extends R> fn) {
+    public static <U, R> Function<MonoTValue<U>, MonoTValue<R>> lift(final Function<? super U, ? extends R> fn) {
         return optTu -> optTu.map(input -> fn.apply(input));
     }
 
@@ -251,7 +293,7 @@ public static <U, R> Function<MonoTValue<U>, MonoTValue<R>> lift(Function<? supe
      * @return Function that accepts and returns an CompletableFutureT
      */
     public static <U1, U2, R> BiFunction<MonoTValue<U1>, MonoTValue<U2>, MonoTValue<R>> lift2(
-            BiFunction<? super U1, ? super U2, ? extends R> fn) {
+            final BiFunction<? super U1, ? super U2, ? extends R> fn) {
         return (optTu1, optTu2) -> optTu1.flatMapT(input1 -> optTu2.map(input2 -> fn.apply(input1, input2)));
     }
 
@@ -262,7 +304,7 @@ public static <U1, U2, R> BiFunction<MonoTValue<U1>, MonoTValue<U2>, MonoTValue<
      * @param anyM AnyM that doesn't contain a monad wrapping an CompletableFuture
      * @return CompletableFutureT
      */
-    public static <A> MonoTValue<A> fromAnyM(AnyMValue<A> anyM) {
+    public static <A> MonoTValue<A> fromAnyM(final AnyMValue<A> anyM) {
         return of(anyM.map(Mono::just));
     }
 
@@ -272,26 +314,28 @@ public static <A> MonoTValue<A> fromAnyM(AnyMValue<A> anyM) {
      * @param monads AnyM that contains a monad wrapping an CompletableFuture
      * @return CompletableFutureT
      */
-    public static <A> MonoTValue<A> of(AnyMValue<Mono<A>> monads) {
+    public static <A> MonoTValue<A> of(final AnyMValue<Mono<A>> monads) {
         return new MonoTValue<>(
-                                   monads);
+                                monads);
     }
 
-    public static <A> MonoTValue<A> of(Mono<A> monads) {
+    public static <A> MonoTValue<A> of(final Mono<A> monads) {
         return MonoT.fromOptional(Optional.of(monads));
     }
 
-    
     /*
      * (non-Javadoc)
      * 
      * @see java.lang.Object#toString()
      */
+    @Override
     public String toString() {
         return String.format("MonoTValue[%s]", run);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.util.function.Supplier#get()
      */
     @Override
@@ -300,60 +344,71 @@ public A get() {
                   .block();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.MonoT#stream()
      */
     @Override
     public ReactiveSeq<A> stream() {
         val maybeEval = run.toMaybe();
         return maybeEval.isPresent() ? Publishers.stream(maybeEval.get())
-                                                
+
                 : ReactiveSeq.of();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.MonoT#iterator()
      */
     @Override
     public Iterator<A> iterator() {
         val maybeEval = run.toMaybe();
         return maybeEval.isPresent() ? Monos.iterator(maybeEval.get())
-                                             
+
                 : Arrays.<A> asList()
                         .iterator();
     }
 
-    /* (non-Javadoc)
-     * @see org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)
      */
     @Override
-    public void subscribe(Subscriber<? super A> s) {
+    public void subscribe(final Subscriber<? super A> s) {
         run.toMaybe()
            .forEach(e -> e.subscribe(s));
 
     }
 
-  
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Value#test(java.lang.Object)
      */
     @Override
-    public boolean test(A t) {
+    public boolean test(final A t) {
         val maybeEval = run.toMaybe();
-        return maybeEval.isPresent() ? Monos.test(maybeEval.get(),t)
-                : false;
+        return maybeEval.isPresent() ? Monos.test(maybeEval.get(), t) : false;
 
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Unit#unit(java.lang.Object)
      */
     @Override
-    public <R> MonoTValue<R> unit(R value) {
+    public <R> MonoTValue<R> unit(final R value) {
         return of(run.unit(Mono.just(value)));
     }
-    /* (non-Javadoc)
+
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.MonoT#empty()
      */
     @Override
@@ -361,51 +416,66 @@ public <R> MonoTValue<R> empty() {
         return of(run.unit(Mono.empty()));
     }
 
-    
-
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Functor#cast(java.lang.Class)
      */
     @Override
-    public <U> MonoTValue<U> cast(Class<? extends U> type) {
+    public <U> MonoTValue<U> cast(final Class<? extends U> type) {
         return (MonoTValue<U>) TransformerValue.super.cast(type);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Functor#trampoline(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.types.Functor#trampoline(java.util.function.Function)
      */
     @Override
-    public <R> MonoTValue<R> trampoline(Function<? super A, ? extends Trampoline<? extends R>> mapper) {
+    public <R> MonoTValue<R> trampoline(final Function<? super A, ? extends Trampoline<? extends R>> mapper) {
         return (MonoTValue<R>) TransformerValue.super.trampoline(mapper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Functor#patternMatch(java.util.function.Function, java.util.function.Supplier)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.types.Functor#patternMatch(java.util.function.Function,
+     * java.util.function.Supplier)
      */
     @Override
-    public <R> MonoTValue<R> patternMatch(Function<CheckValue1<A, R>, CheckValue1<A, R>> case1, Supplier<? extends R> otherwise) {
+    public <R> MonoTValue<R> patternMatch(final Function<CheckValue1<A, R>, CheckValue1<A, R>> case1,
+            final Supplier<? extends R> otherwise) {
         return (MonoTValue<R>) TransformerValue.super.patternMatch(case1, otherwise);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Filterable#ofType(java.lang.Class)
      */
     @Override
-    public <U> MonoTValue<U> ofType(Class<? extends U> type) {
+    public <U> MonoTValue<U> ofType(final Class<? extends U> type) {
 
         return (MonoTValue<U>) MonoT.super.ofType(type);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.types.Filterable#filterNot(java.util.function.Predicate)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.types.Filterable#filterNot(java.util.function.Predicate)
      */
     @Override
-    public MonoTValue<A> filterNot(Predicate<? super A> fn) {
+    public MonoTValue<A> filterNot(final Predicate<? super A> fn) {
 
         return (MonoTValue<A>) MonoT.super.filterNot(fn);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.types.Filterable#notNull()
      */
     @Override
@@ -413,40 +483,55 @@ public MonoTValue<A> notNull() {
 
         return (MonoTValue<A>) MonoT.super.notNull();
     }
-    
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.MonoT#bind(java.util.function.Function)
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see com.aol.cyclops.reactor.transformer.MonoT#bind(java.util.function.
+     * Function)
      */
     @Override
-    public <B> MonoTValue<B> bind(Function<? super A, MonoT<? extends B>> f) {
-        return (MonoTValue<B>)MonoT.super.bind(f);
+    public <B> MonoTValue<B> bind(final Function<? super A, MonoT<? extends B>> f) {
+        return (MonoTValue<B>) MonoT.super.bind(f);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see com.aol.cyclops.reactor.transformer.MonoT#nest()
      */
     @Override
     public MonoTValue<MonadicValue<A>> nest() {
-        return (MonoTValue<MonadicValue<A>>)MonoT.super.nest();
+        return (MonoTValue<MonadicValue<A>>) MonadicValue1.super.nest();
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.MonoT#coflatMap(java.util.function.Function)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.transformer.MonoT#coflatMap(java.util.function.
+     * Function)
      */
     @Override
-    public <R> MonoTValue<R> coflatMap(Function<? super MonadicValue<A>, R> mapper) {
-        return (MonoTValue<R>)MonoT.super.coflatMap(mapper);
+    public <R> MonoTValue<R> coflatMap(final Function<? super MonadicValue<A>, R> mapper) {
+        return (MonoTValue<R>) MonadicValue1.super.coflatMap(mapper);
     }
 
-    /* (non-Javadoc)
-     * @see com.aol.cyclops.reactor.transformer.MonoT#combineEager(com.aol.cyclops.Monoid, com.aol.cyclops.types.MonadicValue)
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * com.aol.cyclops.reactor.transformer.MonoT#combineEager(com.aol.cyclops.
+     * Monoid, com.aol.cyclops.types.MonadicValue)
      */
     @Override
-    public MonoTValue<A> combineEager(Monoid<A> monoid, MonadicValue<? extends A> v2) {
-        return (MonoTValue<A>)MonoT.super.combineEager(monoid, v2);
+    public MonoTValue<A> combineEager(final Monoid<A> monoid, final MonadicValue<? extends A> v2) {
+        return (MonoTValue<A>) MonadicValue1.super.combineEager(monoid, v2);
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#hashCode()
      */
     @Override
@@ -454,11 +539,13 @@ public int hashCode() {
         return run.hashCode();
     }
 
-    /* (non-Javadoc)
+    /*
+     * (non-Javadoc)
+     * 
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
-    public boolean equals(Object o) {
+    public boolean equals(final Object o) {
         if (o instanceof MonoTValue) {
             return run.equals(((MonoTValue) o).run);
         }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/types/ReactorConvertable.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/types/ReactorConvertable.java
index 292ab3e0..c3fe3700 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/types/ReactorConvertable.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/types/ReactorConvertable.java
@@ -11,22 +11,21 @@
  * @param <T> type of elements contained
  */
 public interface ReactorConvertable<T> {
-    
+
     /**
      * Convert this type to a Reactor Flux
      * 
      * @return Reactor Flux
      */
     Flux<T> flux();
-    
+
     /**
      * Convert this type to a Reactor Mono
      * 
      * @return Reactor Mono
      */
-     default Mono<T> mono(){
-         return Mono.from(flux());
-     }
-    
+    default Mono<T> mono() {
+        return Mono.from(flux());
+    }
 
 }