From f056c287947d7aad4704207281e936c7a259cdc7 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 21 Jun 2017 23:10:15 +0100
Subject: [PATCH 01/30] pCollecitons fix #271

---
 .../java/cyclops/collections/clojure/ClojureListX.java | 10 ++++++++--
 .../main/java/cyclops/collections/dexx/DexxListX.java  |  9 +++++++--
 .../streams/observables/AsyncSequentialTest.java       |  7 +++++++
 cyclops-rxjava2/build.gradle                           |  2 +-
 .../AsyncRSExtensionOperatorsTest.java                 |  5 +++--
 .../syncflux/SyncRSExtensionOperatorsTest.java         |  7 ++++---
 .../streams/observables/AsyncSequentialTest.java       |  7 +++++++
 .../java/cyclops/collections/scala/ScalaListX.java     | 10 +++++++---
 .../main/java/cyclops/collections/vavr/VavrListX.java  |  7 +++++--
 9 files changed, 49 insertions(+), 15 deletions(-)

diff --git a/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java b/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java
index 1f6eaab7..caf58699 100644
--- a/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java
+++ b/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java
@@ -7,6 +7,7 @@
 import java.util.stream.Stream;
 
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
+import com.aol.cyclops2.data.collections.extensions.lazy.immutable.FoldToList;
 import com.aol.cyclops2.data.collections.extensions.lazy.immutable.LazyLinkedListX;
 import com.aol.cyclops2.types.Unwrapable;
 import com.aol.cyclops2.types.foldable.Evaluation;
@@ -28,6 +29,8 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class ClojureListX<T> extends AbstractList<T>implements PStack<T>, Unwrapable {
 
+    static final FoldToList gen = (it, i)-> ClojureListX.from(from(it,i));
+
     public static <T> LinkedListX<T> listX(ReactiveSeq<T> stream){
         return fromStream(stream);
     }
@@ -35,6 +38,9 @@ public static <T> LinkedListX<T> copyFromCollection(CollectionX<T> vec) {
         return fromPStack(new ClojureListX<T>(from(vec.iterator(),0)),toPStack());
 
     }
+    public static <T> LazyLinkedListX<T> from(IPersistentList q) {
+        return fromPStack(new ClojureListX<>(q), toPStack());
+    }
     private static <E> IPersistentList from(final Iterator<E> i, int depth) {
 
         if(!i.hasNext())
@@ -55,7 +61,7 @@ public <R> R unwrap() {
     public static <T> LazyLinkedListX<T> fromStream(Stream<T> stream) {
         Reducer<PStack<T>> s = toPStack();
         return new LazyLinkedListX<T>(null,
-                                  ReactiveSeq.fromStream(stream), s, Evaluation.LAZY);
+                                  ReactiveSeq.fromStream(stream), s,gen, Evaluation.LAZY);
     }
 
     /**
@@ -177,7 +183,7 @@ public static <T> LazyLinkedListX<T> PStack(List<T> q) {
     }
 
     private static <T> LazyLinkedListX<T> fromPStack(PStack<T> s, Reducer<PStack<T>> pStackReducer) {
-        return new LazyLinkedListX<T>(s,null, pStackReducer, Evaluation.LAZY);
+        return new LazyLinkedListX<T>(s,null, pStackReducer, gen,Evaluation.LAZY);
     }
 
     @SafeVarargs
diff --git a/cyclops-dexx/src/main/java/cyclops/collections/dexx/DexxListX.java b/cyclops-dexx/src/main/java/cyclops/collections/dexx/DexxListX.java
index 3d4ffc97..b06bf5d6 100644
--- a/cyclops-dexx/src/main/java/cyclops/collections/dexx/DexxListX.java
+++ b/cyclops-dexx/src/main/java/cyclops/collections/dexx/DexxListX.java
@@ -7,6 +7,7 @@
 import java.util.stream.Stream;
 
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
+import com.aol.cyclops2.data.collections.extensions.lazy.immutable.FoldToList;
 import com.aol.cyclops2.data.collections.extensions.lazy.immutable.LazyLinkedListX;
 import com.aol.cyclops2.types.Unwrapable;
 import com.aol.cyclops2.types.foldable.Evaluation;
@@ -35,6 +36,10 @@ public class DexxListX<T> extends AbstractList<T>implements PStack<T>, Unwrapabl
     public static <T> LinkedListX<T> listX(ReactiveSeq<T> stream){
         return fromStream(stream);
     }
+    static final FoldToList gen = (it, i)-> DexxListX.from(from(it,i));
+    public static <T> LazyLinkedListX<T> from(List<T> q) {
+        return fromPStack(new DexxListX<>(q), toPStack());
+    }
     @Override
     public <R> R unwrap() {
         return (R)list;
@@ -60,7 +65,7 @@ private static <E> List<E> from(final Iterator<E> i, int depth) {
      */
     public static <T> LazyLinkedListX<T> fromStream(Stream<T> stream) {
         Reducer<PStack<T>> r = toPStack();
-        return new LazyLinkedListX<T>(null, ReactiveSeq.fromStream(stream),  r, Evaluation.LAZY);
+        return new LazyLinkedListX<T>(null, ReactiveSeq.fromStream(stream),  r, gen,Evaluation.LAZY);
     }
 
     /**
@@ -189,7 +194,7 @@ public static <T> LazyLinkedListX<T> PStack(List<T> q) {
                                       toPStack());
     }
     private static <T> LazyLinkedListX<T> fromPStack(PStack<T> s, Reducer<PStack<T>> pStackReducer) {
-        return new LazyLinkedListX<T>(s,null,pStackReducer, Evaluation.LAZY);
+        return new LazyLinkedListX<T>(s,null,pStackReducer,gen, Evaluation.LAZY);
     }
 
 
diff --git a/cyclops-rx/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java b/cyclops-rx/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java
index 8ea6b13a..1aa121e9 100644
--- a/cyclops-rx/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java
+++ b/cyclops-rx/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java
@@ -23,6 +23,7 @@
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static java.util.Arrays.asList;
 import static org.hamcrest.CoreMatchers.equalTo;
@@ -58,7 +59,13 @@ protected <U> ReactiveSeq<U> of(U... array){
     public void testCycle() {
 
     }
+    @Test
+    public void limitReplay() {
+        final ReactiveSeq<Integer> t = of(1).map(i -> i).flatMap(i -> Stream.of(i));
+        assertThat(t.limit(1).toList(), equalTo(ListX.of(1)));
+         t.limit(1).toList();
 
+    }
     @Test
     public void subscribe3ErrorOnComplete() throws InterruptedException {
         List<Integer> result = new ArrayList<>();
diff --git a/cyclops-rxjava2/build.gradle b/cyclops-rxjava2/build.gradle
index cc1d57f8..0def6ef5 100644
--- a/cyclops-rxjava2/build.gradle
+++ b/cyclops-rxjava2/build.gradle
@@ -66,7 +66,7 @@ modifyPom {
 		inceptionYear '2017'
 
 		groupId 'com.aol.cyclops'
-		artifactId 'cyclops-rx'
+		artifactId 'cyclops-rxjava2'
 		version "$version"
 		
 		scm {
diff --git a/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSExtensionOperatorsTest.java b/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSExtensionOperatorsTest.java
index 348219a6..2b9d9d43 100644
--- a/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSExtensionOperatorsTest.java
+++ b/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSExtensionOperatorsTest.java
@@ -187,11 +187,12 @@ public void singleOptonal2(){
     public void limitTime(){
         List<Integer> result = of(1,2,3,4,5,6)
                 .peek(i->sleep(i*100))
-                .limit(1000,TimeUnit.MILLISECONDS)
+                .limit(1000, TimeUnit.MILLISECONDS)
                 .toList();
 
 
-        assertThat(result,equalTo(Arrays.asList(1,2,3)));
+        assertThat(result,contains(1,2,3));
+        assertThat(result.size(),lessThan(5));
     }
     @Test
     public void limitTimeEmpty(){
diff --git a/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/syncflux/SyncRSExtensionOperatorsTest.java b/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/syncflux/SyncRSExtensionOperatorsTest.java
index 381e328f..307362f3 100644
--- a/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/syncflux/SyncRSExtensionOperatorsTest.java
+++ b/cyclops-rxjava2/src/test/java/cyclops/streams/flowables/syncflux/SyncRSExtensionOperatorsTest.java
@@ -182,9 +182,10 @@ public void limitTime(){
 										.peek(i->sleep(i*100))
 										.limit(1000,TimeUnit.MILLISECONDS)
 										.toList();
-		
-		
-		assertThat(result,equalTo(Arrays.asList(1,2,3)));
+
+
+		assertThat(result,contains(1,2,3));
+		assertThat(result.size(),lessThan(5));
 	}
 	@Test
 	public void limitTimeEmpty(){
diff --git a/cyclops-rxjava2/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java b/cyclops-rxjava2/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java
index a793f6f3..b4d5fb71 100644
--- a/cyclops-rxjava2/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java
+++ b/cyclops-rxjava2/src/test/java/cyclops/streams/observables/AsyncSequentialTest.java
@@ -23,6 +23,7 @@
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static java.util.Arrays.asList;
 import static org.hamcrest.CoreMatchers.equalTo;
@@ -58,7 +59,13 @@ protected <U> ReactiveSeq<U> of(U... array){
     public void testCycle() {
 
     }
+    @Test
+    public void limitReplay() {
+        final ReactiveSeq<Integer> t = of(1).map(i -> i).flatMap(i -> Stream.of(i));
+        assertThat(t.limit(1).toList(), equalTo(ListX.of(1)));
+        t.limit(1).toList();
 
+    }
     @Test
     public void subscribe3ErrorOnComplete() throws InterruptedException {
         List<Integer> result = new ArrayList<>();
diff --git a/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaListX.java b/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaListX.java
index f60a424f..b17bc633 100644
--- a/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaListX.java
+++ b/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaListX.java
@@ -12,6 +12,7 @@
 
 import com.aol.cyclops.scala.collections.HasScalaCollection;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
+import com.aol.cyclops2.data.collections.extensions.lazy.immutable.FoldToList;
 import com.aol.cyclops2.data.collections.extensions.lazy.immutable.LazyLinkedListX;
 import com.aol.cyclops2.types.Unwrapable;
 import com.aol.cyclops2.types.foldable.Evaluation;
@@ -39,6 +40,7 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class ScalaListX<T> extends AbstractList<T>implements PStack<T>, HasScalaCollection<T>, Unwrapable {
 
+    static final FoldToList gen = (it, i)-> ScalaListX.from(from(it,i));
     public static <T> LinkedListX<T> listX(ReactiveSeq<T> stream){
         return fromStream(stream);
     }
@@ -46,7 +48,9 @@ public static <T> LinkedListX<T> listX(ReactiveSeq<T> stream){
     public <R> R unwrap() {
         return (R)list;
     }
-
+    public static <T> LazyLinkedListX<T> from(List<T> q) {
+        return fromPStack(new ScalaListX<>(q), toPStack());
+    }
     public LazyLinkedListX<T> plusLoop(int max, IntFunction<T> value) {
 
         List<T> toUse = list;
@@ -73,7 +77,7 @@ public LazyLinkedListX<T> plusLoop(Supplier<Optional<T>> supplier) {
      * @return LazyLinkedListX
      */
     public static <T> LazyLinkedListX<T> fromStream(Stream<T> stream) {
-        return new LazyLinkedListX<T>(null,ReactiveSeq.fromStream(stream), toPStack(), Evaluation.LAZY);
+        return new LazyLinkedListX<T>(null,ReactiveSeq.fromStream(stream), toPStack(), gen, Evaluation.LAZY);
     }
 
     /**
@@ -171,7 +175,7 @@ public static <T> LazyLinkedListX<T> lazyList(List<T> vector){
     }
 
     private static <T> LazyLinkedListX<T> fromPStack(PStack<T> s, Reducer<PStack<T>> pStackReducer) {
-        return new LazyLinkedListX<T>(s,null, pStackReducer,Evaluation.LAZY);
+        return new LazyLinkedListX<T>(s,null, pStackReducer,gen, Evaluation.LAZY);
     }
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrListX.java b/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrListX.java
index c48a5c22..25708b9a 100644
--- a/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrListX.java
+++ b/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrListX.java
@@ -10,6 +10,7 @@
 import java.util.stream.Stream;
 
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
+import com.aol.cyclops2.data.collections.extensions.lazy.immutable.FoldToList;
 import com.aol.cyclops2.data.collections.extensions.lazy.immutable.LazyLinkedListX;
 import com.aol.cyclops2.types.Unwrapable;
 import com.aol.cyclops2.types.foldable.Evaluation;
@@ -36,12 +37,14 @@ public <R> R unwrap() {
         return (R)list;
     }
 
+    static final FoldToList gen = (it,i)-> VavrListX.from(from(it,i));
 
     public static <T> LinkedListX<T> copyFromCollection(CollectionX<T> vec) {
         List<T> list = from(vec.iterator(),0);
         return from(list);
 
     }
+
     private static <E> List<E> from(final Iterator<E> i, int depth) {
 
         if(!i.hasNext())
@@ -57,7 +60,7 @@ private static <E> List<E> from(final Iterator<E> i, int depth) {
      */
     public static <T> LazyLinkedListX<T> fromStream(Stream<T> stream) {
         Reducer<PStack<T>> p = toPStack();
-        return new LazyLinkedListX<T>(null, ReactiveSeq.fromStream(stream),p, Evaluation.LAZY);
+        return new LazyLinkedListX<T>(null, ReactiveSeq.fromStream(stream),p, gen,Evaluation.LAZY);
     }
 
     /**
@@ -152,7 +155,7 @@ public static <T> LazyLinkedListX<T> empty(){
         return fromPStack(new VavrListX<T>(List.empty()), toPStack());
     }
     private static <T> LazyLinkedListX<T> fromPStack(PStack<T> s, Reducer<PStack<T>> pStackReducer) {
-        return new LazyLinkedListX<T>(s,null, pStackReducer, Evaluation.LAZY);
+        return new LazyLinkedListX<T>(s,null, pStackReducer, gen, Evaluation.LAZY);
     }
     public static <T> LazyLinkedListX<T> singleton(T t){
         return fromPStack(new VavrListX<T>(List.of(t)), toPStack());

From 4f0a047c2ac6a81ec0eec04fc37e9f63948d6bc0 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Tue, 4 Jul 2017 18:09:49 +0100
Subject: [PATCH 02/30] 2.0.0-FINAL migration

---
 .../collections/clojure/ClojureListX.java     |  2 +
 .../cyclops/functionaljava/hkt/ListKind.java  | 25 ++++----
 .../functionaljava/hkt/NonEmptyListKind.java  | 27 ++++----
 .../functionaljava/hkt/OptionKind.java        | 25 ++++----
 .../functionaljava/hkt/StreamKind.java        | 25 ++++----
 .../companion/functionaljava/Lists.java       | 34 +++++-----
 .../functionaljava/NonEmptyLists.java         | 20 +++---
 .../companion/functionaljava/Options.java     | 40 ++++++------
 .../companion/functionaljava/Streams.java     | 34 +++++-----
 .../hkt/typeclesses/instances/ListsTest.java  | 16 ++---
 .../instances/NonEmptyListsTest.java          |  8 +--
 .../hkt/typeclesses/instances/OptionTest.java | 16 ++---
 .../cyclops/guava/hkt/FluentIterableKind.java | 21 +++----
 .../aol/cyclops/guava/hkt/OptionalKind.java   | 19 +++---
 .../companion/guava/FluentIterables.java      | 42 ++++++-------
 .../cyclops/companion/guava/Optionals.java    | 40 ++++++------
 .../instances/FluentIterablesTest.java        | 28 +++------
 .../typeclasses/instances/OptionalsTest.java  | 16 ++---
 cyclops-reactor/readme.md                     |  8 +--
 .../com/aol/cyclops/reactor/hkt/FluxKind.java | 21 +++----
 .../com/aol/cyclops/reactor/hkt/MonoKind.java | 19 +++---
 .../java/cyclops/companion/reactor/Fluxs.java | 44 ++++++-------
 .../java/cyclops/companion/reactor/Monos.java | 40 ++++++------
 .../hkt/typeclasses/instances/FluxTest.java   | 16 ++---
 .../hkt/typeclasses/instances/MonosTest.java  | 30 +++++----
 cyclops-rx/readme.md                          |  4 +-
 .../cyclops/rx/adapter/ObservableAdapter.java | 22 +++----
 .../aol/cyclops/rx/hkt/ObservableKind.java    | 12 ++--
 .../cyclops/companion/rx/Observables.java     | 62 ++++++++-----------
 .../main/java/cyclops/monads/RxWitness.java   |  6 +-
 .../test/java/com/aol/cyclops/rx/RxTest.java  |  7 +--
 .../typeclasses/instances/ObservableTest.java | 34 +++++-----
 cyclops-rxjava2/readme.md                     | 12 ++--
 .../rx2/adapter/ObservableAdapter.java        | 22 +++----
 .../com/aol/cyclops/rx2/hkt/FlowableKind.java | 21 +++----
 .../com/aol/cyclops/rx2/hkt/MaybeKind.java    | 19 +++---
 .../aol/cyclops/rx2/hkt/ObservableKind.java   | 21 +++----
 .../com/aol/cyclops/rx2/hkt/SingleKind.java   | 10 +--
 .../java/cyclops/companion/rx2/Flowables.java | 44 ++++++-------
 .../java/cyclops/companion/rx2/Maybes.java    | 40 ++++++------
 .../cyclops/companion/rx2/Observables.java    | 52 ++++++++--------
 .../java/cyclops/companion/rx2/Singles.java   | 40 ++++++------
 .../main/java/cyclops/monads/Rx2Witness.java  |  6 +-
 .../test/java/com/aol/cyclops/rx/RxTest.java  |  4 +-
 .../typeclasses/instances/FlowableTest.java   | 28 +++------
 .../hkt/typeclasses/instances/MaybesTest.java | 29 +++++----
 .../typeclasses/instances/ObservableTest.java | 28 +++------
 .../typeclasses/instances/SinglesTest.java    | 30 +++++----
 cyclops-vavr/readme.md                        |  4 +-
 .../com/aol/cyclops/vavr/hkt/ArrayKind.java   | 23 +++----
 .../com/aol/cyclops/vavr/hkt/FutureKind.java  | 19 +++---
 .../com/aol/cyclops/vavr/hkt/LazyKind.java    | 21 +++----
 .../com/aol/cyclops/vavr/hkt/ListKind.java    | 21 +++----
 .../com/aol/cyclops/vavr/hkt/OptionKind.java  | 18 +++---
 .../com/aol/cyclops/vavr/hkt/QueueKind.java   | 23 +++----
 .../com/aol/cyclops/vavr/hkt/StreamKind.java  | 21 +++----
 .../com/aol/cyclops/vavr/hkt/VectorKind.java  | 22 +++----
 .../java/cyclops/companion/vavr/Arrays.java   | 34 +++++-----
 .../java/cyclops/companion/vavr/Futures.java  | 40 ++++++------
 .../java/cyclops/companion/vavr/Lazys.java    | 42 +++++++------
 .../java/cyclops/companion/vavr/Lists.java    | 42 ++++++-------
 .../java/cyclops/companion/vavr/Options.java  | 40 ++++++------
 .../java/cyclops/companion/vavr/Queues.java   | 34 +++++-----
 .../java/cyclops/companion/vavr/Streams.java  | 34 +++++-----
 .../java/cyclops/companion/vavr/Vectors.java  | 34 +++++-----
 .../main/java/cyclops/monads/VavrWitness.java |  9 +++
 .../hkt/typeclesses/instances/ArraysTest.java | 16 ++---
 .../typeclesses/instances/FuturesTest.java    | 16 ++---
 .../instances/LazyInstancesTest.java          | 48 +++++++-------
 .../hkt/typeclesses/instances/ListTest.java   | 28 +++------
 .../typeclesses/instances/OptionsTest.java    | 16 ++---
 .../hkt/typeclesses/instances/QueuesTest.java | 16 ++---
 .../hkt/typeclesses/instances/StreamTest.java | 36 +++++------
 .../typeclesses/instances/VectorsTest.java    | 16 ++---
 gradle.properties                             |  4 +-
 75 files changed, 880 insertions(+), 966 deletions(-)

diff --git a/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java b/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java
index caf58699..aabed254 100644
--- a/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java
+++ b/cyclops-clojure/src/main/java/cyclops/collections/clojure/ClojureListX.java
@@ -16,6 +16,7 @@
 import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
 import org.jooq.lambda.tuple.Tuple2;
+import org.pcollections.ConsPStack;
 import org.pcollections.PStack;
 
 
@@ -41,6 +42,7 @@ public static <T> LinkedListX<T> copyFromCollection(CollectionX<T> vec) {
     public static <T> LazyLinkedListX<T> from(IPersistentList q) {
         return fromPStack(new ClojureListX<>(q), toPStack());
     }
+
     private static <E> IPersistentList from(final Iterator<E> i, int depth) {
 
         if(!i.hasNext())
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
index fdb0c076..cba49189 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
@@ -2,9 +2,12 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.function.Function;
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.list;
 import fj.Equal;
 import fj.F;
 import fj.F0;
@@ -33,21 +36,17 @@
 /**
  * Simulates Higher Kinded Types for List's
  * 
- * ListKind is a List and a Higher Kinded Type (ListKind.µ,T)
+ * ListKind is a List and a Higher Kinded Type (list,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the List
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public  class ListKind<T> implements Higher<ListKind.µ, T> {
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
+public  class ListKind<T> implements Higher<list, T> {
+
+    public <R> ListKind<R> fold(Function<? super List<?  super T>,? extends List<R>> op){
+        return widen(op.apply(boxed));
     }
     public static <T> ListKind<T> list(final T... values) {
         
@@ -73,9 +72,9 @@ public static <T> ListKind<T> widen(final List<T> list) {
      * @param list HTK encoded type containing  a List to widen
      * @return HKT encoded type with a widened List
      */
-    public static <C2,T> Higher<C2, Higher<ListKind.µ,T>> widen2(Higher<C2, ListKind<T>> list){
+    public static <C2,T> Higher<C2, Higher<list,T>> widen2(Higher<C2, ListKind<T>> list){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<ListKind.µ,T> must be a ListKind
+        //cast seems safer as Higher<list,T> must be a ListKind
         return (Higher)list;
     }
     /**
@@ -84,7 +83,7 @@ public static <T> ListKind<T> widen(final List<T> list) {
      * @param list HKT encoded list into a ListKind
      * @return ListKind
      */
-    public static <T> ListKind<T> narrowK(final Higher<ListKind.µ, T> list) {
+    public static <T> ListKind<T> narrowK(final Higher<list, T> list) {
        return (ListKind<T>)list;
     }
     /**
@@ -93,7 +92,7 @@ public static <T> ListKind<T> narrowK(final Higher<ListKind.µ, T> list) {
      * @param list Type Constructor to convert back into narrowed type
      * @return ListX from Higher Kinded Type
      */
-    public static <T> List<T> narrow(final Higher<ListKind.µ, T> list) {
+    public static <T> List<T> narrow(final Higher<list, T> list) {
         return ((ListKind)list).narrow();
        
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
index b88e92d6..150a39f8 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
@@ -4,38 +4,37 @@
 import java.util.Iterator;
 import java.util.Spliterator;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.nonEmptyList;
 import fj.F;
 import fj.F2;
 import fj.Ord;
 import fj.P2;
 import fj.data.List;
 import fj.data.NonEmptyList;
+import fj.data.Stream;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 
 /**
  * Simulates Higher Kinded Types for NonEmptyList's
  * 
- * NonEmptyListKind is a NonEmptyList and a Higher Kinded Type (ListKind.µ,T)
+ * NonEmptyListKind is a NonEmptyList and a Higher Kinded Type (list,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the NonEmptyList
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public  class NonEmptyListKind<T> implements Higher<NonEmptyListKind.µ, T> {
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
+public  class NonEmptyListKind<T> implements Higher<nonEmptyList, T> {
+
+    public <R> NonEmptyListKind<R> fold(Function<? super NonEmptyList<?  super T>,? extends NonEmptyList<R>> op){
+        return widen(op.apply(boxed));
     }
-    
     public static<T> NonEmptyListKind<T> of(T first, T...v){
         
         return widen(NonEmptyList.fromList(List.list(v).cons(first)).some());
@@ -61,9 +60,9 @@ public static <T> NonEmptyListKind<T> widen(final NonEmptyList<T> list) {
      * @param list HTK encoded type containing  a NonEmptyList to widen
      * @return HKT encoded type with a widened NonEmptyList
      */
-    public static <C2,T> Higher<C2, Higher<NonEmptyListKind.µ,T>> widen2(Higher<C2, NonEmptyListKind<T>> list){
+    public static <C2,T> Higher<C2, Higher<nonEmptyList,T>> widen2(Higher<C2, NonEmptyListKind<T>> list){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<ListKind.µ,T> must be a NonEmptyListKind
+        //cast seems safer as Higher<list,T> must be a NonEmptyListKind
         return (Higher)list;
     }
     /**
@@ -72,7 +71,7 @@ public static <T> NonEmptyListKind<T> widen(final NonEmptyList<T> list) {
      * @param list HKT encoded list into a NonEmptyListKind
      * @return NonEmptyListKind
      */
-    public static <T> NonEmptyListKind<T> narrowK(final Higher<NonEmptyListKind.µ, T> list) {
+    public static <T> NonEmptyListKind<T> narrowK(final Higher<nonEmptyList, T> list) {
        return (NonEmptyListKind<T>)list;
     }
     /**
@@ -81,7 +80,7 @@ public static <T> NonEmptyListKind<T> narrowK(final Higher<NonEmptyListKind.µ,
      * @param list Type Constructor to convert back into narrowed type
      * @return NonEmptyListX from Higher Kinded Type
      */
-    public static <T> NonEmptyList<T> narrow(final Higher<NonEmptyListKind.µ, T> list) {
+    public static <T> NonEmptyList<T> narrow(final Higher<nonEmptyList, T> list) {
         return ((NonEmptyListKind)list).narrow();
        
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
index 6b7e7917..40ea4bbe 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
@@ -11,6 +11,8 @@
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.control.Maybe;
+import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.option;
 import fj.F;
 import fj.F0;
 import fj.F2;
@@ -40,24 +42,19 @@
 /**
  * Simulates Higher Kinded Types for Option's
  * 
- * OptionKind is a Option and a Higher Kinded Type (OptionKind.µ,T)
+ * OptionKind is a Option and a Higher Kinded Type (option,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the Option
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final class OptionKind<T> implements Higher<OptionKind.µ, T>, Iterable<T> {
-    private final Option<T> boxed;  
-   
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
+public final class OptionKind<T> implements Higher<option, T>, Iterable<T> {
+    private final Option<T> boxed;
+    public <R> OptionKind<R> fold(Function<? super Option<?  super T>,? extends Option<R>> op){
+        return widen(op.apply(boxed));
     }
+
     /**
      * @return An HKT encoded empty Option
      */
@@ -96,7 +93,7 @@ public static <T> OptionKind<T> widen(final Maybe<T> option) {
      * @param future HKT encoded list into a OptionKind
      * @return OptionKind
      */
-    public static <T> OptionKind<T> narrowK(final Higher<OptionKind.µ, T> future) {
+    public static <T> OptionKind<T> narrowK(final Higher<option, T> future) {
        return (OptionKind<T>)future;
     }
     /**
@@ -105,8 +102,8 @@ public static <T> OptionKind<T> narrowK(final Higher<OptionKind.µ, T> future) {
      * @param Option Type Constructor to convert back into narrowed type
      * @return Option from Higher Kinded Type
      */
-    public static <T> Option<T> narrow(final Higher<OptionKind.µ, T> Option) {
-        //has to be an OptionKind as only OptionKind can implement Higher<OptionKind.µ, T>
+    public static <T> Option<T> narrow(final Higher<option, T> Option) {
+        //has to be an OptionKind as only OptionKind can implement Higher<option, T>
          return ((OptionKind<T>)Option).boxed;
         
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
index 2db3e7d8..0ade4f48 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
@@ -2,9 +2,12 @@
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.function.Function;
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.stream;
 import fj.Equal;
 import fj.F;
 import fj.F0;
@@ -34,15 +37,8 @@
  * @param <T> Data type stored within the Stream
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public  class StreamKind<T> implements Higher<StreamKind.µ, T> {
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+public  class StreamKind<T> implements Higher<stream, T> {
+
     public static <T> StreamKind<T> stream(final T... values) {
         
         return widen(Stream.stream(values));
@@ -67,9 +63,9 @@ public static <T> StreamKind<T> widen(final Stream<T> stream) {
      * @param stream HTK encoded type containing  a Stream to widen
      * @return HKT encoded type with a widened Stream
      */
-    public static <C2,T> Higher<C2, Higher<StreamKind.µ,T>> widen2(Higher<C2, StreamKind<T>> stream){
+    public static <C2,T> Higher<C2, Higher<stream,T>> widen2(Higher<C2, StreamKind<T>> stream){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<StreamKind.µ,T> must be a StreamKind
+        //cast seems safer as Higher<stream,T> must be a StreamKind
         return (Higher)stream;
     }
     /**
@@ -78,7 +74,7 @@ public static <T> StreamKind<T> widen(final Stream<T> stream) {
      * @param stream HKT encoded stream into a StreamKind
      * @return StreamKind
      */
-    public static <T> StreamKind<T> narrowK(final Higher<StreamKind.µ, T> stream) {
+    public static <T> StreamKind<T> narrowK(final Higher<stream, T> stream) {
        return (StreamKind<T>)stream;
     }
     /**
@@ -87,11 +83,14 @@ public static <T> StreamKind<T> narrowK(final Higher<StreamKind.µ, T> stream) {
      * @param stream Type Constructor to convert back into narrowed type
      * @return StreamX from Higher Kinded Type
      */
-    public static <T> Stream<T> narrow(final Higher<StreamKind.µ, T> stream) {
+    public static <T> Stream<T> narrow(final Higher<stream, T> stream) {
         return ((StreamKind)stream).narrow();
        
     }
 
+    public <R> StreamKind<R> fold(Function<? super Stream<?  super T>,? extends Stream<R>> op){
+        return widen(op.apply(boxed));
+    }
 
     private final Stream<T> boxed;
 
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
index 13ade87a..9852e181 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
@@ -333,7 +333,7 @@ public static class Instances {
          *
          * @return A functor for Lists
          */
-        public static <T,R>Functor<ListKind.µ> functor(){
+        public static <T,R>Functor<list> functor(){
             BiFunction<ListKind<T>,Function<? super T, ? extends R>,ListKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -352,8 +352,8 @@ public static class Instances {
          *
          * @return A factory for Lists
          */
-        public static <T> Pure<ListKind.µ> unit(){
-            return General.<ListKind.µ,T>unit(Instances::of);
+        public static <T> Pure<list> unit(){
+            return General.<list,T>unit(Instances::of);
         }
         /**
          *
@@ -392,7 +392,7 @@ public static class Instances {
          *
          * @return A zipper for Lists
          */
-        public static <T,R> Applicative<ListKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<list> zippingApplicative(){
             BiFunction<ListKind< Function<T, R>>,ListKind<T>,ListKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -422,9 +422,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Lists
          */
-        public static <T,R> Monad<ListKind.µ> monad(){
+        public static <T,R> Monad<list> monad(){
 
-            BiFunction<Higher<ListKind.µ,T>,Function<? super T, ? extends Higher<ListKind.µ,R>>,Higher<ListKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<list,T>,Function<? super T, ? extends Higher<list,R>>,Higher<list,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -444,7 +444,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<ListKind.µ> monadZero(){
+        public static <T,R> MonadZero<list> monadZero(){
 
             return General.monadZero(monad(), ListKind.widen(List.list()));
         }
@@ -460,9 +460,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Lists by concatenation
          */
-        public static <T> MonadPlus<ListKind.µ> monadPlus(){
+        public static <T> MonadPlus<list> monadPlus(){
             Monoid<ListKind<T>> m = Monoid.of(ListKind.widen(List.list()), Instances::concat);
-            Monoid<Higher<ListKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -481,15 +481,15 @@ public static class Instances {
          * @param m Monoid to use for combining Lists
          * @return Type class for combining Lists
          */
-        public static <T> MonadPlus<ListKind.µ> monadPlus(Monoid<ListKind<T>> m){
-            Monoid<Higher<ListKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<list> monadPlus(Monoid<ListKind<T>> m){
+            Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<ListKind.µ> traverse(){
+        public static <C2,T> Traverse<list> traverse(){
 
             BiFunction<Applicative<C2>,ListKind<Higher<C2, T>>,Higher<C2, ListKind<T>>> sequenceFn = (ap, list) -> {
 
@@ -507,7 +507,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<ListKind.µ,Higher<C2, T>>,Higher<C2, Higher<ListKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<list,Higher<C2, T>>,Higher<C2, Higher<list,T>>> sequenceNarrow  =
                     (a,b) -> ListKind.widen2(sequenceFn.apply(a, ListKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -528,9 +528,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<ListKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<ListKind.µ,T>,T> foldRightFn =  (m, l)-> ListX.fromIterable(ListKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<ListKind.µ,T>,T> foldLeftFn = (m, l)-> ListX.fromIterable(ListKind.narrow(l)).reduce(m);
+        public static <T> Foldable<list> foldable(){
+            BiFunction<Monoid<T>,Higher<list,T>,T> foldRightFn =  (m, l)-> ListX.fromIterable(ListKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<list,T>,T> foldLeftFn = (m, l)-> ListX.fromIterable(ListKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -545,7 +545,7 @@ private static <T,R> ListKind<R> ap(ListKind<Function< T, R>> lt, ListKind<T> li
 
             return ListKind.widen(lt.zipWith(list.narrow(),(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<ListKind.µ,R> flatMap(Higher<ListKind.µ,T> lt, Function<? super T, ? extends  Higher<ListKind.µ,R>> fn){
+        private static <T,R> Higher<list,R> flatMap(Higher<list,T> lt, Function<? super T, ? extends  Higher<list,R>> fn){
             return ListKind.widen(ListKind.narrow(lt).bind(in->fn.andThen(ListKind::narrow).apply(in)));
         }
         private static <T,R> ListKind<R> map(ListKind<T> lt, Function<? super T, ? extends R> fn){
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
index 62bbfaa6..4ce14708 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
@@ -197,7 +197,7 @@ public static class Instances {
          *
          * @return A functor for NonEmptyLists
          */
-        public static <T,R>Functor<NonEmptyListKind.µ> functor(){
+        public static <T,R>Functor<nonEmptyList> functor(){
             BiFunction<NonEmptyListKind<T>,Function<? super T, ? extends R>,NonEmptyListKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -216,8 +216,8 @@ public static class Instances {
          *
          * @return A factory for NonEmptyLists
          */
-        public static <T> Pure<NonEmptyListKind.µ> unit(){
-            return General.<NonEmptyListKind.µ,T>unit(Instances::of);
+        public static <T> Pure<nonEmptyList> unit(){
+            return General.<nonEmptyList,T>unit(Instances::of);
         }
         /**
          *
@@ -256,7 +256,7 @@ public static class Instances {
          *
          * @return A zipper for NonEmptyLists
          */
-        public static <T,R> Applicative<NonEmptyListKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<nonEmptyList> zippingApplicative(){
             BiFunction<NonEmptyListKind< Function<T, R>>,NonEmptyListKind<T>,NonEmptyListKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -286,9 +286,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for NonEmptyLists
          */
-        public static <T,R> Monad<NonEmptyListKind.µ> monad(){
+        public static <T,R> Monad<nonEmptyList> monad(){
 
-            BiFunction<Higher<NonEmptyListKind.µ,T>,Function<? super T, ? extends Higher<NonEmptyListKind.µ,R>>,Higher<NonEmptyListKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<nonEmptyList,T>,Function<? super T, ? extends Higher<nonEmptyList,R>>,Higher<nonEmptyList,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
 
@@ -312,9 +312,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<NonEmptyListKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<NonEmptyListKind.µ,T>,T> foldRightFn =  (m, l)-> ListX.fromIterable(NonEmptyListKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<NonEmptyListKind.µ,T>,T> foldLeftFn = (m, l)-> ListX.fromIterable(NonEmptyListKind.narrow(l)).reduce(m);
+        public static <T> Foldable<nonEmptyList> foldable(){
+            BiFunction<Monoid<T>,Higher<nonEmptyList,T>,T> foldRightFn =  (m, l)-> ListX.fromIterable(NonEmptyListKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<nonEmptyList,T>,T> foldLeftFn = (m, l)-> ListX.fromIterable(NonEmptyListKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -326,7 +326,7 @@ private static <T,R> NonEmptyListKind<R> ap(NonEmptyListKind<Function< T, R>> lt
 
             return NonEmptyListKind.widen(lt.zipWith(list.narrow().toList(),(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<NonEmptyListKind.µ,R> flatMap(Higher<NonEmptyListKind.µ,T> lt, Function<? super T, ? extends  Higher<NonEmptyListKind.µ,R>> fn){
+        private static <T,R> Higher<nonEmptyList,R> flatMap(Higher<nonEmptyList,T> lt, Function<? super T, ? extends  Higher<nonEmptyList,R>> fn){
             return NonEmptyListKind.widen(NonEmptyListKind.narrow(lt).bind(in->fn.andThen(NonEmptyListKind::narrow).apply(in)));
         }
         private static <T,R> NonEmptyListKind<R> map(NonEmptyListKind<T> lt, Function<? super T, ? extends R> fn){
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
index 42a517df..c9ba327b 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
@@ -619,7 +619,7 @@ public static class Instances {
          *
          * @return A functor for Options
          */
-        public static <T,R>Functor<OptionKind.µ> functor(){
+        public static <T,R>Functor<option> functor(){
             BiFunction<OptionKind<T>,Function<? super T, ? extends R>,OptionKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -638,8 +638,8 @@ public static class Instances {
          *
          * @return A factory for Options
          */
-        public static <T> Pure<OptionKind.µ> unit(){
-            return General.<OptionKind.µ,T>unit(Instances::of);
+        public static <T> Pure<option> unit(){
+            return General.<option,T>unit(Instances::of);
         }
         /**
          *
@@ -678,7 +678,7 @@ public static class Instances {
          *
          * @return A zipper for Options
          */
-        public static <T,R> Applicative<OptionKind.µ> applicative(){
+        public static <T,R> Applicative<option> applicative(){
             BiFunction<OptionKind< Function<T, R>>,OptionKind<T>,OptionKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -708,9 +708,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Options
          */
-        public static <T,R> Monad<OptionKind.µ> monad(){
+        public static <T,R> Monad<option> monad(){
 
-            BiFunction<Higher<OptionKind.µ,T>,Function<? super T, ? extends Higher<OptionKind.µ,R>>,Higher<OptionKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<option,T>,Function<? super T, ? extends Higher<option,R>>,Higher<option,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -730,7 +730,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<OptionKind.µ> monadZero(){
+        public static <T,R> MonadZero<option> monadZero(){
 
             return General.monadZero(monad(), OptionKind.empty());
         }
@@ -746,12 +746,12 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Options by concatenation
          */
-        public static <T> MonadPlus<OptionKind.µ> monadPlus(){
+        public static <T> MonadPlus<option> monadPlus(){
             Monoid<Option<T>> mn = Monoid.of(Option.none(), (a, b) -> a.isSome() ? a : b);
             Monoid<OptionKind<T>> m = Monoid.of(OptionKind.widen(mn.zero()), (f, g)-> OptionKind.widen(
                     mn.apply(OptionKind.narrow(f), OptionKind.narrow(g))));
 
-            Monoid<Higher<OptionKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<option,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -770,15 +770,15 @@ public static class Instances {
          * @param m Monoid to use for combining Options
          * @return Type class for combining Options
          */
-        public static <T> MonadPlus<OptionKind.µ> monadPlus(Monoid<OptionKind<T>> m){
-            Monoid<Higher<OptionKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<option> monadPlus(Monoid<OptionKind<T>> m){
+            Monoid<Higher<option,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<OptionKind.µ> traverse(){
+        public static <C2,T> Traverse<option> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -798,13 +798,13 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<OptionKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<OptionKind.µ,T>,T> foldRightFn =  (m, l)-> OptionKind.narrow(l).orSome(m.zero());
-            BiFunction<Monoid<T>,Higher<OptionKind.µ,T>,T> foldLeftFn = (m, l)-> OptionKind.narrow(l).orSome(m.zero());
+        public static <T> Foldable<option> foldable(){
+            BiFunction<Monoid<T>,Higher<option,T>,T> foldRightFn =  (m, l)-> OptionKind.narrow(l).orSome(m.zero());
+            BiFunction<Monoid<T>,Higher<option,T>,T> foldLeftFn = (m, l)-> OptionKind.narrow(l).orSome(m.zero());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<OptionKind.µ> comonad(){
-            Function<? super Higher<OptionKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(OptionKind::narrow).some();
+        public static <T> Comonad<option> comonad(){
+            Function<? super Higher<option, T>, ? extends T> extractFn = maybe -> maybe.convert(OptionKind::narrow).some();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -818,7 +818,7 @@ private static <T,R> OptionKind<R> ap(OptionKind<Function< T, R>> lt, OptionKind
             return OptionKind.widen(mb);
 
         }
-        private static <T,R> Higher<OptionKind.µ,R> flatMap(Higher<OptionKind.µ,T> lt, Function<? super T, ? extends  Higher<OptionKind.µ,R>> fn){
+        private static <T,R> Higher<option,R> flatMap(Higher<option,T> lt, Function<? super T, ? extends  Higher<option,R>> fn){
             return OptionKind.widen(OptionKind.narrow(lt).bind(in->fn.andThen(OptionKind::narrow).apply(in)));
         }
         private static <T,R> OptionKind<R> map(OptionKind<T> lt, Function<? super T, ? extends R> fn){
@@ -827,8 +827,8 @@ private static <T,R> OptionKind<R> map(OptionKind<T> lt, Function<? super T, ? e
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<OptionKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                              Higher<OptionKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<option, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                              Higher<option, T> ds){
             Option<T> opt = OptionKind.narrow(ds);
             return opt.isSome()?   applicative.map(OptionKind::of, fn.apply(opt.some())) :
                     applicative.unit(OptionKind.empty());
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
index 0c622c8d..8e59de5f 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
@@ -335,7 +335,7 @@ public class Instances {
          *
          * @return A functor for Streams
          */
-        public static <T,R>Functor<StreamKind.µ> functor(){
+        public static <T,R>Functor<stream> functor(){
             BiFunction<StreamKind<T>,Function<? super T, ? extends R>,StreamKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -354,8 +354,8 @@ public class Instances {
          *
          * @return A factory for Streams
          */
-        public static <T> Pure<StreamKind.µ> unit(){
-            return General.<StreamKind.µ,T>unit(Instances::of);
+        public static <T> Pure<stream> unit(){
+            return General.<stream,T>unit(Instances::of);
         }
         /**
          *
@@ -394,7 +394,7 @@ public class Instances {
          *
          * @return A zipper for Streams
          */
-        public static <T,R> Applicative<StreamKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<stream> zippingApplicative(){
             BiFunction<StreamKind< Function<T, R>>,StreamKind<T>,StreamKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -424,9 +424,9 @@ public class Instances {
          *
          * @return Type class with monad functions for Streams
          */
-        public static <T,R> Monad<StreamKind.µ> monad(){
+        public static <T,R> Monad<stream> monad(){
 
-            BiFunction<Higher<StreamKind.µ,T>,Function<? super T, ? extends Higher<StreamKind.µ,R>>,Higher<StreamKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<stream,T>,Function<? super T, ? extends Higher<stream,R>>,Higher<stream,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -446,7 +446,7 @@ public class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<StreamKind.µ> monadZero(){
+        public static <T,R> MonadZero<stream> monadZero(){
 
             return General.monadZero(monad(), StreamKind.widen(Stream.stream()));
         }
@@ -462,9 +462,9 @@ public class Instances {
          * </pre>
          * @return Type class for combining Streams by concatenation
          */
-        public static <T> MonadPlus<StreamKind.µ> monadPlus(){
+        public static <T> MonadPlus<stream> monadPlus(){
             Monoid<StreamKind<T>> m = Monoid.of(StreamKind.widen(Stream.stream()), Instances::concat);
-            Monoid<Higher<StreamKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<stream,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -483,15 +483,15 @@ public class Instances {
          * @param m Monoid to use for combining Streams
          * @return Type class for combining Streams
          */
-        public static <T> MonadPlus<StreamKind.µ> monadPlus(Monoid<StreamKind<T>> m){
-            Monoid<Higher<StreamKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<stream> monadPlus(Monoid<StreamKind<T>> m){
+            Monoid<Higher<stream,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<StreamKind.µ> traverse(){
+        public static <C2,T> Traverse<stream> traverse(){
 
             BiFunction<Applicative<C2>,StreamKind<Higher<C2, T>>,Higher<C2, StreamKind<T>>> sequenceFn = (ap, stream) -> {
 
@@ -509,7 +509,7 @@ public class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<StreamKind.µ,Higher<C2, T>>,Higher<C2, Higher<StreamKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<stream,Higher<C2, T>>,Higher<C2, Higher<stream,T>>> sequenceNarrow  =
                     (a,b) -> StreamKind.widen2(sequenceFn.apply(a, StreamKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -530,9 +530,9 @@ public class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<StreamKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<StreamKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<StreamKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).reduce(m);
+        public static <T> Foldable<stream> foldable(){
+            BiFunction<Monoid<T>,Higher<stream,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<stream,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -547,7 +547,7 @@ private static <T,R> StreamKind<R> ap(StreamKind<Function< T, R>> lt, StreamKind
 
             return StreamKind.widen(lt.zipWith(stream.narrow(),(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<StreamKind.µ,R> flatMap(Higher<StreamKind.µ,T> lt, Function<? super T, ? extends  Higher<StreamKind.µ,R>> fn){
+        private static <T,R> Higher<stream,R> flatMap(Higher<stream,T> lt, Function<? super T, ? extends  Higher<stream,R>> fn){
             return StreamKind.widen(StreamKind.narrow(lt).bind(in->fn.andThen(StreamKind::narrow).apply(in)));
         }
         private static <T,R> StreamKind<R> map(StreamKind<T> lt, Function<? super T, ? extends R> fn){
diff --git a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java
index 41d83ceb..79b05497 100644
--- a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java
+++ b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java
@@ -7,6 +7,8 @@
 
 import cyclops.companion.functionaljava.Lists;
 import com.aol.cyclops.functionaljava.hkt.ListKind;
+import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.list;
 import org.junit.Test;
 
 import com.aol.cyclops2.hkt.Higher;
@@ -34,7 +36,7 @@ public void functor(){
         
         ListKind<Integer> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list,equalTo(List.list("hello".length())));
@@ -59,8 +61,8 @@ public void applicative(){
 
         List<Integer> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Lists.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Lists.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(ListKind::narrow);
         
         assertThat(list,equalTo(List.list("hello".length()*2)));
@@ -76,7 +78,7 @@ public void monad(){
         
         ListKind<Integer> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.monad().flatMap((String v) -> Lists.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Lists.Instances.monad().flatMap((String v) -> Lists.Instances.unit().unit(v.length()), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list,equalTo(List.list("hello".length())));
@@ -86,7 +88,7 @@ public void monadZeroFilter(){
         
         ListKind<String> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Lists.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list,equalTo(List.list("hello")));
@@ -96,7 +98,7 @@ public void monadZeroFilterOut(){
         
         ListKind<String> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Lists.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list,equalTo(List.list()));
@@ -135,7 +137,7 @@ public void  foldRight(){
     
     @Test
     public void traverse(){
-       Maybe<Higher<ListKind.µ, Integer>> res = Lists.Instances.traverse()
+       Maybe<Higher<list, Integer>> res = Lists.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), ListKind.list(1,2,3))
                                                          .convert(Maybe::narrowK);
             
diff --git a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/NonEmptyListsTest.java b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/NonEmptyListsTest.java
index 816d33c1..4641efa5 100644
--- a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/NonEmptyListsTest.java
+++ b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/NonEmptyListsTest.java
@@ -29,7 +29,7 @@ public void functor(){
         
         NonEmptyListKind<Integer> list = NonEmptyLists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> NonEmptyLists.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> NonEmptyLists.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(NonEmptyListKind::narrowK);
         
         assertThat(list,equalTo(NonEmptyList.fromList(List.list("hello".length())).some()));
@@ -49,8 +49,8 @@ public void applicative(){
         
         NonEmptyListKind<Integer> list = NonEmptyLists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> NonEmptyLists.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> NonEmptyLists.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h-> NonEmptyLists.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> NonEmptyLists.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(NonEmptyListKind::narrowK);
         
         assertThat(list,equalTo(list("hello".length()*2)));
@@ -73,7 +73,7 @@ public void monad(){
         
         NonEmptyListKind<Integer> list = NonEmptyLists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> NonEmptyLists.Instances.monad().flatMap((String v) -> NonEmptyLists.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> NonEmptyLists.Instances.monad().flatMap((String v) -> NonEmptyLists.Instances.unit().unit(v.length()), h))
                                      .convert(NonEmptyListKind::narrowK);
         
         assertThat(list,equalTo(list("hello".length())));
diff --git a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java
index 41d79139..659b7ef3 100644
--- a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java
+++ b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java
@@ -6,6 +6,8 @@
 
 import cyclops.companion.functionaljava.Options;
 import com.aol.cyclops.functionaljava.hkt.OptionKind;
+import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.option;
 import org.junit.Test;
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.control.Maybe;
@@ -32,7 +34,7 @@ public void functor(){
         
         OptionKind<Integer> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Options.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.some("hello".length())));
@@ -52,8 +54,8 @@ public void applicative(){
         
         OptionKind<Integer> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Options.Instances.applicative().ap(optFn, h))
+                                     .applyHKT(h-> Options.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Options.Instances.applicative().ap(optFn, h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.some("hello".length()*2)));
@@ -69,7 +71,7 @@ public void monad(){
         
         OptionKind<Integer> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.monad().flatMap((String v) -> Options.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Options.Instances.monad().flatMap((String v) -> Options.Instances.unit().unit(v.length()), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.some("hello".length())));
@@ -79,7 +81,7 @@ public void monadZeroFilter(){
         
         OptionKind<String> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Options.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.some("hello")));
@@ -89,7 +91,7 @@ public void monadZeroFilterOut(){
         
         OptionKind<String> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Options.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.none()));
@@ -127,7 +129,7 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-       Maybe<Higher<OptionKind.µ, Integer>> res = Options.Instances.traverse()
+       Maybe<Higher<option, Integer>> res = Options.Instances.traverse()
                                                              .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), OptionKind.of(1))
                                                              .convert(Maybe::narrowK);
        
diff --git a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java
index bf3e52e4..5c8ef459 100644
--- a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java
+++ b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java
@@ -5,6 +5,8 @@
 import java.util.Iterator;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.GuavaWitness;
+import cyclops.monads.GuavaWitness.fluentIterable;
 import cyclops.stream.ReactiveSeq;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
@@ -31,7 +33,7 @@
 /**
  * Simulates Higher Kinded Types for ToCyclopsReact FluentIterable's
  * 
- * FluentIterableKind is a FluentIterable and a Higher Kinded Type (FluentIterableKind.µ,T)
+ * FluentIterableKind is a FluentIterable and a Higher Kinded Type (fluentIterable,T)
  * 
  * @author johnmcclean
  *
@@ -39,16 +41,9 @@
  */
 
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final class FluentIterableKind<E> implements Higher<FluentIterableKind.µ, E>, Publisher<E>, Iterable<E> {
+public final class FluentIterableKind<E> implements Higher<fluentIterable, E>, Publisher<E>, Iterable<E> {
+
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
 
     /**
      * Construct a HKT encoded completed FluentIterable
@@ -92,7 +87,7 @@ public static <T> FluentIterableKind<T> widen(final FluentIterable<T> fluentIter
      * @param flux HTK encoded type containing  a FluentIterable to widen
      * @return HKT encoded type with a widened FluentIterable
      */
-    public static <C2, T> Higher<C2, Higher<FluentIterableKind.µ, T>> widen2(Higher<C2, FluentIterableKind<T>> flux) {
+    public static <C2, T> Higher<C2, Higher<fluentIterable, T>> widen2(Higher<C2, FluentIterableKind<T>> flux) {
         // a functor could be used (if C2 is a functor / one exists for C2 type)
         // instead of casting
         // cast seems safer as Higher<StreamType.µ,T> must be a StreamType
@@ -111,7 +106,7 @@ public static <T> FluentIterableKind<T> widen(final Publisher<T> completableFlue
      * @param future HKT encoded list into a FluentIterableKind
      * @return FluentIterableKind
      */
-    public static <T> FluentIterableKind<T> narrowK(final Higher<FluentIterableKind.µ, T> future) {
+    public static <T> FluentIterableKind<T> narrowK(final Higher<fluentIterable, T> future) {
         return (FluentIterableKind<T>) future;
     }
 
@@ -121,7 +116,7 @@ public static <T> FluentIterableKind<T> narrowK(final Higher<FluentIterableKind.
      * @param fluentIterable Type Constructor to convert back into narrowed type
      * @return FluentIterable from Higher Kinded Type
      */
-    public static <T> FluentIterable<T> narrow(final Higher<FluentIterableKind.µ, T> fluentIterable) {
+    public static <T> FluentIterable<T> narrow(final Higher<fluentIterable, T> fluentIterable) {
 
         return ((FluentIterableKind<T>) fluentIterable).narrow();
 
diff --git a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java
index 81bf39e6..06756e44 100644
--- a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java
+++ b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java
@@ -14,20 +14,23 @@
 
 import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.monads.GuavaWitness;
+import cyclops.monads.GuavaWitness.optional;
+import cyclops.monads.Witness;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 
 /**
  * Simulates Higher Kinded Types for Optional's
  * 
- * OptionalKind is a Optional and a Higher Kinded Type (OptionalKind.µ,T)
+ * OptionalKind is a Optional and a Higher Kinded Type (optional,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the Optional
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public class OptionalKind<T> implements Higher<OptionalKind.µ, T> {
+public class OptionalKind<T> implements Higher<optional, T> {
     /**
      * Witness type
      * 
@@ -82,7 +85,7 @@ public static <T> OptionalKind<T> fromIterable(final Iterable<T> iterable) {
      * @param optional Optional to construct Optional from
      * @return Optional created from Optional
      */
-    public static <T> OptionalKind<T> fromOptional(Higher<cyclops.companion.Optionals.OptionalKind.µ,T> optional){
+    public static <T> OptionalKind<T> fromOptional(Higher<Witness.optional,T> optional){
 
         return widen(FromCyclopsReact.optional(Maybe.fromOptional(optional)));
     }
@@ -110,12 +113,12 @@ public static <T> OptionalKind<T> widen(final Maybe<T> option) {
      * @param future HKT encoded list into a OptionalKind
      * @return OptionalKind
      */
-    public static <T> OptionalKind<T> narrowK(final Higher<OptionalKind.µ, T> future) {
+    public static <T> OptionalKind<T> narrowK(final Higher<optional, T> future) {
        return (OptionalKind<T>)future;
     }
-    public static <C2,T> Higher<C2, Higher<OptionalKind.µ,T>> widen2(Higher<C2, OptionalKind<T>> nestedOptional){
+    public static <C2,T> Higher<C2, Higher<optional,T>> widen2(Higher<C2, OptionalKind<T>> nestedOptional){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<OptionalKind.µ,T> must be a StreamType
+        //cast seems safer as Higher<optional,T> must be a StreamType
         return (Higher)nestedOptional;
     }
     /**
@@ -124,7 +127,7 @@ public static <T> OptionalKind<T> narrowK(final Higher<OptionalKind.µ, T> futur
      * @param optional Type Constructor to convert back into narrowed type
      * @return Optional from Higher Kinded Type
      */
-    public static <T> java.util.Optional<T> narrowOptional(final Higher<OptionalKind.µ, T> optional) {
+    public static <T> java.util.Optional<T> narrowOptional(final Higher<optional, T> optional) {
         
          return ToCyclopsReact.maybe(narrow(optional)).toOptional();
         
@@ -193,7 +196,7 @@ public static <T> OptionalKind<T> widen(final Optional<T> maybe) {
      * @param maybe Type Constructor to convert back into narrowed type
      * @return OptionalX from Higher Kinded Type
      */
-    public static <T> Optional<T> narrow(final Higher<OptionalKind.µ, T> maybe) {
+    public static <T> Optional<T> narrow(final Higher<optional, T> maybe) {
         if (maybe instanceof Optional)
             return (Optional) maybe;
         //this code should be unreachable due to HKT type checker
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
index 1b88d174..50465226 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
@@ -349,7 +349,7 @@ public class Instances {
          *
          * @return A functor for FluentIterables
          */
-        public static <T,R>Functor<FluentIterableKind.µ> functor(){
+        public static <T,R>Functor<fluentIterable> functor(){
             BiFunction<FluentIterableKind<T>,Function<? super T, ? extends R>,FluentIterableKind<R>> transform = Instances::transform;
             return General.functor(transform);
         }
@@ -368,8 +368,8 @@ public class Instances {
          *
          * @return A factory for FluentIterables
          */
-        public static <T> Pure<FluentIterableKind.µ> unit(){
-            return General.<FluentIterableKind.µ,T>unit(Instances::of);
+        public static <T> Pure<fluentIterable> unit(){
+            return General.<fluentIterable,T>unit(Instances::of);
         }
         /**
          *
@@ -407,7 +407,7 @@ public class Instances {
          *
          * @return A zipper for FluentIterables
          */
-        public static <T,R> Applicative<FluentIterableKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<fluentIterable> zippingApplicative(){
             BiFunction<FluentIterableKind< Function<T, R>>,FluentIterableKind<T>,FluentIterableKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -437,9 +437,9 @@ public class Instances {
          *
          * @return Type class with monad functions for FluentIterables
          */
-        public static <T,R> Monad<FluentIterableKind.µ> monad(){
+        public static <T,R> Monad<fluentIterable> monad(){
 
-            BiFunction<Higher<FluentIterableKind.µ,T>,Function<? super T, ? extends Higher<FluentIterableKind.µ,R>>,Higher<FluentIterableKind.µ,R>> transformAndConcat = Instances::transformAndConcat;
+            BiFunction<Higher<fluentIterable,T>,Function<? super T, ? extends Higher<fluentIterable,R>>,Higher<fluentIterable,R>> transformAndConcat = Instances::transformAndConcat;
             return General.monad(zippingApplicative(), transformAndConcat);
         }
         /**
@@ -459,10 +459,10 @@ public class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<FluentIterableKind.µ> monadZero(){
-            BiFunction<Higher<FluentIterableKind.µ,T>,Predicate<? super T>,Higher<FluentIterableKind.µ,T>> filter = Instances::filter;
-            Supplier<Higher<FluentIterableKind.µ, T>> zero = ()-> FluentIterableKind.widen(FluentIterable.of());
-            return General.<FluentIterableKind.µ,T,R>monadZero(monad(), zero,filter);
+        public static <T,R> MonadZero<fluentIterable> monadZero(){
+            BiFunction<Higher<fluentIterable,T>,Predicate<? super T>,Higher<fluentIterable,T>> filter = Instances::filter;
+            Supplier<Higher<fluentIterable, T>> zero = ()-> FluentIterableKind.widen(FluentIterable.of());
+            return General.<fluentIterable,T,R>monadZero(monad(), zero,filter);
         }
         /**
          * <pre>
@@ -476,9 +476,9 @@ public class Instances {
          * </pre>
          * @return Type class for combining FluentIterables by concatenation
          */
-        public static <T> MonadPlus<FluentIterableKind.µ> monadPlus(){
+        public static <T> MonadPlus<fluentIterable> monadPlus(){
             Monoid<FluentIterableKind<T>> m = Monoid.of(FluentIterableKind.widen(FluentIterable.<T>of()), Instances::concat);
-            Monoid<Higher<FluentIterableKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<fluentIterable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -497,15 +497,15 @@ public class Instances {
          * @param m Monoid to use for combining FluentIterables
          * @return Type class for combining FluentIterables
          */
-        public static <T> MonadPlus<FluentIterableKind.µ> monadPlus(Monoid<FluentIterableKind<T>> m){
-            Monoid<Higher<FluentIterableKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<fluentIterable> monadPlus(Monoid<FluentIterableKind<T>> m){
+            Monoid<Higher<fluentIterable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<FluentIterableKind.µ> traverse(){
+        public static <C2,T> Traverse<fluentIterable> traverse(){
             BiFunction<Applicative<C2>,FluentIterableKind<Higher<C2, T>>,Higher<C2, FluentIterableKind<T>>> sequenceFn = (ap, flux) -> {
 
                 Higher<C2,FluentIterableKind<T>> identity = ap.unit(FluentIterableKind.widen(FluentIterable.of()));
@@ -520,7 +520,7 @@ public class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<FluentIterableKind.µ,Higher<C2, T>>,Higher<C2, Higher<FluentIterableKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<fluentIterable,Higher<C2, T>>,Higher<C2, Higher<fluentIterable,T>>> sequenceNarrow  =
                     (a,b) -> FluentIterableKind.widen2(sequenceFn.apply(a, FluentIterableKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -540,9 +540,9 @@ public class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<FluentIterableKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<FluentIterableKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(FluentIterableKind.narrowK(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<FluentIterableKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(FluentIterableKind.narrowK(l)).reduce(m);
+        public static <T> Foldable<fluentIterable> foldable(){
+            BiFunction<Monoid<T>,Higher<fluentIterable,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(FluentIterableKind.narrowK(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<fluentIterable,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(FluentIterableKind.narrowK(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -555,13 +555,13 @@ private <T> FluentIterableKind<T> of(T value){
         private static <T,R> FluentIterableKind<R> ap(FluentIterableKind<Function< T, R>> lt, FluentIterableKind<T> flux){
             return FluentIterableKind.widen(lt.toReactiveSeq().zip(flux,(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<FluentIterableKind.µ,R> transformAndConcat(Higher<FluentIterableKind.µ,T> lt, Function<? super T, ? extends  Higher<FluentIterableKind.µ,R>> fn){
+        private static <T,R> Higher<fluentIterable,R> transformAndConcat(Higher<fluentIterable,T> lt, Function<? super T, ? extends  Higher<fluentIterable,R>> fn){
             return FluentIterableKind.widen(FluentIterableKind.narrowK(lt).transformAndConcat(i->fn.andThen(FluentIterableKind::narrowK).apply(i)));
         }
         private static <T,R> FluentIterableKind<R> transform(FluentIterableKind<T> lt, Function<? super T, ? extends R> fn){
             return FluentIterableKind.widen(lt.transform(i->fn.apply(i)));
         }
-        private static <T> FluentIterableKind<T> filter(Higher<FluentIterableKind.µ,T> lt, Predicate<? super T> fn){
+        private static <T> FluentIterableKind<T> filter(Higher<fluentIterable,T> lt, Predicate<? super T> fn){
             return FluentIterableKind.widen(FluentIterableKind.narrow(lt).filter(i->fn.test(i)));
         }
     }
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
index 25167198..d06094e1 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
@@ -630,7 +630,7 @@ public class Instances {
          *
          * @return A functor for Optionals
          */
-        public static <T,R> Functor<OptionalKind.µ> functor(){
+        public static <T,R> Functor<optional> functor(){
             BiFunction<OptionalKind<T>,Function<? super T, ? extends R>,OptionalKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -649,8 +649,8 @@ public class Instances {
          *
          * @return A factory for Optionals
          */
-        public static <T> Pure<OptionalKind.µ> unit(){
-            return General.<OptionalKind.µ,T>unit(Instances::of);
+        public static <T> Pure<optional> unit(){
+            return General.<optional,T>unit(Instances::of);
         }
         /**
          *
@@ -689,7 +689,7 @@ public class Instances {
          *
          * @return A zipper for Optionals
          */
-        public static <T,R> Applicative<OptionalKind.µ> applicative(){
+        public static <T,R> Applicative<optional> applicative(){
             BiFunction<OptionalKind< Function<T, R>>,OptionalKind<T>,OptionalKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -719,9 +719,9 @@ public class Instances {
          *
          * @return Type class with monad functions for Optionals
          */
-        public static <T,R> Monad<OptionalKind.µ> monad(){
+        public static <T,R> Monad<optional> monad(){
 
-            BiFunction<Higher<OptionalKind.µ,T>,Function<? super T, ? extends Higher<OptionalKind.µ,R>>,Higher<OptionalKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<optional,T>,Function<? super T, ? extends Higher<optional,R>>,Higher<optional,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -741,7 +741,7 @@ public class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<OptionalKind.µ> monadZero(){
+        public static <T,R> MonadZero<optional> monadZero(){
 
             return General.monadZero(monad(), OptionalKind.absent());
         }
@@ -757,12 +757,12 @@ public class Instances {
          * </pre>
          * @return Type class for combining Optionals by concatenation
          */
-        public static <T> MonadPlus<OptionalKind.µ> monadPlus(){
+        public static <T> MonadPlus<optional> monadPlus(){
             Monoid<Optional<T>> mn = Monoid.of(Optional.absent(), (a, b) -> a.isPresent() ? a : b);
             Monoid<OptionalKind<T>> m = Monoid.of(OptionalKind.widen(mn.zero()), (f, g)-> OptionalKind.widen(
                     mn.apply(OptionalKind.narrow(f), OptionalKind.narrow(g))));
 
-            Monoid<Higher<OptionalKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<optional,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -781,15 +781,15 @@ public class Instances {
          * @param m Monoid to use for combining Optionals
          * @return Type class for combining Optionals
          */
-        public static <T> MonadPlus<OptionalKind.µ> monadPlus(Monoid<OptionalKind<T>> m){
-            Monoid<Higher<OptionalKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<optional> monadPlus(Monoid<OptionalKind<T>> m){
+            Monoid<Higher<optional,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<OptionalKind.µ> traverse(){
+        public static <C2,T> Traverse<optional> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -809,13 +809,13 @@ public class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<OptionalKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<OptionalKind.µ,T>,T> foldRightFn =  (m, l)-> OptionalKind.narrow(l).or(m.zero());
-            BiFunction<Monoid<T>,Higher<OptionalKind.µ,T>,T> foldLeftFn = (m, l)-> OptionalKind.narrow(l).or(m.zero());
+        public static <T> Foldable<optional> foldable(){
+            BiFunction<Monoid<T>,Higher<optional,T>,T> foldRightFn =  (m, l)-> OptionalKind.narrow(l).or(m.zero());
+            BiFunction<Monoid<T>,Higher<optional,T>,T> foldLeftFn = (m, l)-> OptionalKind.narrow(l).or(m.zero());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<OptionalKind.µ> comonad(){
-            Function<? super Higher<OptionalKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(OptionalKind::narrow).get();
+        public static <T> Comonad<optional> comonad(){
+            Function<? super Higher<optional, T>, ? extends T> extractFn = maybe -> maybe.convert(OptionalKind::narrow).get();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -828,7 +828,7 @@ private static <T,R> OptionalKind<R> ap(OptionalKind<Function< T, R>> lt, Option
             return OptionalKind.widen(mb);
 
         }
-        private static <T,R> Higher<OptionalKind.µ,R> flatMap(Higher<OptionalKind.µ,T> lt, Function<? super T, ? extends  Higher<OptionalKind.µ,R>> fn){
+        private static <T,R> Higher<optional,R> flatMap(Higher<optional,T> lt, Function<? super T, ? extends  Higher<optional,R>> fn){
             return OptionalKind.widen(OptionalKind.narrowOptional(lt).flatMap(in->fn.andThen(OptionalKind::narrowOptional).apply(in)));
         }
         private static <T,R> OptionalKind<R> map(OptionalKind<T> lt, Function<? super T, ? extends R> fn){
@@ -837,8 +837,8 @@ private static <T,R> OptionalKind<R> map(OptionalKind<T> lt, Function<? super T,
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<OptionalKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                                Higher<OptionalKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<optional, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                                Higher<optional, T> ds){
             Optional<T> opt = OptionalKind.narrow(ds);
             return opt.isPresent()?   applicative.map(OptionalKind::just, fn.apply(opt.get())) :
                     applicative.unit(OptionalKind.absent());
diff --git a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
index 1a302f3b..d645d114 100644
--- a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
+++ b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
@@ -14,6 +14,8 @@
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Lambda;
+import cyclops.monads.GuavaWitness;
+import cyclops.monads.GuavaWitness.fluentIterable;
 import cyclops.stream.ReactiveSeq;
 import org.junit.Test;
 
@@ -35,7 +37,7 @@ public void functor(){
         
         FluentIterableKind<Integer> list = FluentIterables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> FluentIterables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> FluentIterables.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(FluentIterableKind::narrowK);
         
         assertThat(list.toList(),equalTo(Arrays.asList("hello".length())));
@@ -55,8 +57,8 @@ public void applicative(){
         
         FluentIterableKind<Integer> list = FluentIterables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> FluentIterables.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> FluentIterables.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h-> FluentIterables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> FluentIterables.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(FluentIterableKind::narrowK);
         
         assertThat(list.toList(),equalTo(Arrays.asList("hello".length()*2)));
@@ -72,7 +74,7 @@ public void monad(){
         
         FluentIterableKind<Integer> list = FluentIterables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> FluentIterables.Instances.monad().flatMap((String v) -> FluentIterables.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> FluentIterables.Instances.monad().flatMap((String v) -> FluentIterables.Instances.unit().unit(v.length()), h))
                                      .convert(FluentIterableKind::narrowK);
         
         assertThat(list.toList(),equalTo(Arrays.asList("hello".length())));
@@ -82,7 +84,7 @@ public void monadZeroFilter(){
         
         FluentIterableKind<String> list = FluentIterables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> FluentIterables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> FluentIterables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(FluentIterableKind::narrowK);
         
         assertThat(list.toList(),equalTo(Arrays.asList("hello")));
@@ -92,7 +94,7 @@ public void monadZeroFilterOut(){
         
         FluentIterableKind<String> list = FluentIterables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> FluentIterables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> FluentIterables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(FluentIterableKind::narrowK);
         
         assertThat(list.toList(),equalTo(Arrays.asList()));
@@ -105,17 +107,7 @@ public void monadPlus(){
                                       .convert(FluentIterableKind::narrowK);
         assertThat(list.toList(),equalTo(Arrays.asList(10)));
     }
-/**
-    @Test
-    public void monadPlusNonEmpty(){
-        
-        Monoid<FluentIterableKind<Integer>> m = Monoid.of(FluentIterableKind.widen(FluentIterable.empty()), (a,b)->a.isEmpty() ? b : a);
-        FluentIterableKind<Integer> list = FluentIterables.Instances.<Integer>monadPlus(m)
-                                      .plus(FluentIterableKind.widen(FluentIterable.of(5)), FluentIterableKind.widen(FluentIterable.of(10)))
-                                      .convert(FluentIterableKind::narrowK);
-        assertThat(list,equalTo(Arrays.asList(5)));
-    }
-**/
+
     @Test
     public void  foldLeft(){
         int sum  = FluentIterables.Instances.foldable()
@@ -132,7 +124,7 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-       Maybe<Higher<FluentIterableKind.µ, Integer>> res = FluentIterables.Instances.traverse()
+       Maybe<Higher<fluentIterable, Integer>> res = FluentIterables.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), FluentIterableKind.just(1,2,3))
                                                          .convert(Maybe::narrowK);
        
diff --git a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java
index 86d9ba76..9d2bc172 100644
--- a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java
+++ b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java
@@ -8,6 +8,8 @@
 import cyclops.companion.guava.Optionals;
 import com.aol.cyclops.guava.hkt.OptionalKind;
 import cyclops.function.Monoid;
+import cyclops.monads.GuavaWitness;
+import cyclops.monads.GuavaWitness.optional;
 import org.junit.Test;
 
 import com.aol.cyclops2.hkt.Higher;
@@ -33,7 +35,7 @@ public void functor(){
         
         OptionalKind<Integer> opt = Optionals.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Optionals.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Optionals.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(OptionalKind::narrowK);
         
         assertThat(opt,equalTo(Optional.of("hello".length())));
@@ -53,8 +55,8 @@ public void applicative(){
         
         OptionalKind<Integer> opt = Optionals.Instances.unit()
                                              .unit("hello")
-                                             .apply(h-> Optionals.Instances.functor().map((String v) ->v.length(), h))
-                                             .apply(h-> Optionals.Instances.applicative().ap(optFn, h))
+                                             .applyHKT(h-> Optionals.Instances.functor().map((String v) ->v.length(), h))
+                                             .applyHKT(h-> Optionals.Instances.applicative().ap(optFn, h))
                                              .convert(OptionalKind::narrowK);
                 
         assertThat(opt,equalTo(Optional.of("hello".length()*2)));
@@ -70,7 +72,7 @@ public void monad(){
         
         OptionalKind<Integer> opt = Optionals.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Optionals.Instances.monad().flatMap((String v) -> Optionals.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Optionals.Instances.monad().flatMap((String v) -> Optionals.Instances.unit().unit(v.length()), h))
                                      .convert(OptionalKind::narrowK);
         
         assertThat(opt,equalTo(Optional.of("hello".length())));
@@ -80,7 +82,7 @@ public void monadZeroFilter(){
         
         OptionalKind<String> opt = Optionals.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Optionals.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Optionals.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(OptionalKind::narrowK);
         
         assertThat(opt,equalTo(Optional.of("hello")));
@@ -90,7 +92,7 @@ public void monadZeroFilterOut(){
         
         OptionalKind<String> opt = Optionals.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Optionals.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Optionals.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(OptionalKind::narrowK);
         
         assertThat(opt,equalTo(Optional.absent()));
@@ -128,7 +130,7 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-       Maybe<Higher<OptionalKind.µ, Integer>> res = Optionals.Instances.traverse()
+       Maybe<Higher<optional, Integer>> res = Optionals.Instances.traverse()
                                                                  .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), OptionalKind.of(1))
                                                                  .convert(Maybe::narrowK);
        
diff --git a/cyclops-reactor/readme.md b/cyclops-reactor/readme.md
index 353592b8..e7238c51 100644
--- a/cyclops-reactor/readme.md
+++ b/cyclops-reactor/readme.md
@@ -360,20 +360,20 @@ MonoKind<Integer> mono = MonoKind.widen(Mono.just(1));
 MonoKind implements the Higher interface which captures that our type is both a Mono and takes a data type of Integer
 
 ```java
-Higher<MonoKind.µ, Integer> higher = mono;
+Higher<mono, Integer> higher = mono;
 ```
 
 We can use the Traverse and Applicative typeclasses to sequence a Mono with a Maybe into a Maybe with a Mono.
 ```java
-Traverse<MonoKind.µ> traverse = Monos.Instances.traverse();
+Traverse<mono> traverse = Monos.Instances.traverse();
 Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
 ```
 
 ```java
-Traverse<MonoKind.µ> traverse = Monos.Instances.traverse();        
+Traverse<mono> traverse = Monos.Instances.traverse();        
 Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
         
-Higher<Maybe.µ, Higher<MonoKind.µ, Integer>> result = traverse.sequenceA(applicative, MonoKind.widen(Mono.just(Maybe.just(1))));
+Higher<Maybe.µ, Higher<mono, Integer>> result = traverse.sequenceA(applicative, MonoKind.widen(Mono.just(Maybe.just(1))));
 ```
 Our result is a little ugly - we should convert it back into a more readable form.
 
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java
index d7a31a2c..5c3014fa 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java
@@ -2,6 +2,8 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.ReactorWitness;
+import cyclops.monads.ReactorWitness.flux;
 import cyclops.stream.ReactiveSeq;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -24,7 +26,7 @@
 /**
  * Simulates Higher Kinded Types for Reactor Flux's
  * 
- * FluxKind is a Flux and a Higher Kinded Type (FluxKind.µ,T)
+ * FluxKind is a Flux and a Higher Kinded Type (flux,T)
  * 
  * @author johnmcclean
  *
@@ -32,20 +34,13 @@
  */
 
 
-public final class FluxKind<T> implements Higher<FluxKind.µ, T>, Publisher<T> {
+public final class FluxKind<T> implements Higher<flux, T>, Publisher<T> {
 
     private FluxKind(Flux<T> boxed) {
         this.boxed = boxed;
     }
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+
     
     /**
      * Construct a HKT encoded completed Flux
@@ -86,7 +81,7 @@ public static <T> FluxKind<T> widen(final Flux<T> completableFlux) {
      * @param flux HTK encoded type containing  a Flux to widen
      * @return HKT encoded type with a widened Flux
      */
-    public static <C2,T> Higher<C2, Higher<FluxKind.µ,T>> widen2(Higher<C2, FluxKind<T>> flux){
+    public static <C2,T> Higher<C2, Higher<flux,T>> widen2(Higher<C2, FluxKind<T>> flux){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
         //cast seems safer as Higher<StreamType.µ,T> must be a StreamType
         return (Higher)flux;
@@ -104,7 +99,7 @@ public static <T> FluxKind<T> widen(final Publisher<T> completableFlux) {
      * @param future HKT encoded list into a FluxKind
      * @return FluxKind
      */
-    public static <T> FluxKind<T> narrowK(final Higher<FluxKind.µ, T> future) {
+    public static <T> FluxKind<T> narrowK(final Higher<flux, T> future) {
        return (FluxKind<T>)future;
     }
 
@@ -114,7 +109,7 @@ public static <T> FluxKind<T> narrowK(final Higher<FluxKind.µ, T> future) {
      * @param completableFlux Type Constructor to convert back into narrowed type
      * @return Flux from Higher Kinded Type
      */
-    public static <T> Flux<T> narrow(final Higher<FluxKind.µ, T> completableFlux) {
+    public static <T> Flux<T> narrow(final Higher<flux, T> completableFlux) {
       
             return ((FluxKind<T>)completableFlux).narrow();
            
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java
index 14a12318..95070f13 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java
@@ -13,6 +13,8 @@
 
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.async.Future;
+import cyclops.monads.ReactorWitness;
+import cyclops.monads.ReactorWitness.mono;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
@@ -34,7 +36,7 @@
 /**
  * Simulates Higher Kinded Types for Reactor Mono's
  * 
- * MonoKind is a Mono and a Higher Kinded Type (MonoKind.µ,T)
+ * MonoKind is a Mono and a Higher Kinded Type (mono,T)
  * 
  * @author johnmcclean
  *
@@ -42,19 +44,12 @@
  */
 
 
-public final class MonoKind<T> implements Higher<MonoKind.µ, T>, Publisher<T> {
+public final class MonoKind<T> implements Higher<mono, T>, Publisher<T> {
     private MonoKind(Mono<T> boxed) {
         this.boxed = boxed;
     }
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+
     
     /**
      * Construct a HKT encoded completed Mono
@@ -99,7 +94,7 @@ public static <T> MonoKind<T> widen(final Publisher<T> completableMono) {
      * @param future HKT encoded list into a MonoKind
      * @return MonoKind
      */
-    public static <T> MonoKind<T> narrowK(final Higher<MonoKind.µ, T> future) {
+    public static <T> MonoKind<T> narrowK(final Higher<mono, T> future) {
        return (MonoKind<T>)future;
     }
 
@@ -109,7 +104,7 @@ public static <T> MonoKind<T> narrowK(final Higher<MonoKind.µ, T> future) {
      * @param completableMono Type Constructor to convert back into narrowed type
      * @return Mono from Higher Kinded Type
      */
-    public static <T> Mono<T> narrow(final Higher<MonoKind.µ, T> completableMono) {
+    public static <T> Mono<T> narrow(final Higher<mono, T> completableMono) {
       
             return ((MonoKind<T>)completableMono).narrow();
            
diff --git a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
index 53bdd37e..cc383f26 100644
--- a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
+++ b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
@@ -540,7 +540,7 @@ public static class Instances {
          *
          * @return A functor for Fluxs
          */
-        public static <T,R>Functor<FluxKind.µ> functor(){
+        public static <T,R>Functor<flux> functor(){
             BiFunction<FluxKind<T>,Function<? super T, ? extends R>,FluxKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -559,9 +559,9 @@ public static class Instances {
          *
          * @return A factory for Fluxs
          */
-        public static <T> Pure<FluxKind.µ> unit(){
-            Function<T, Higher<FluxKind.µ, T>> unitRef = Instances::of;
-            return General.<FluxKind.µ,T>unit(unitRef);
+        public static <T> Pure<flux> unit(){
+            Function<T, Higher<flux, T>> unitRef = Instances::of;
+            return General.<flux,T>unit(unitRef);
         }
         /**
          *
@@ -599,7 +599,7 @@ public static class Instances {
          *
          * @return A zipper for Fluxs
          */
-        public static <T,R> Applicative<FluxKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<flux> zippingApplicative(){
             BiFunction<FluxKind< Function<T, R>>,FluxKind<T>,FluxKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -629,9 +629,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Fluxs
          */
-        public static <T,R> Monad<FluxKind.µ> monad(){
+        public static <T,R> Monad<flux> monad(){
 
-            BiFunction<Higher<FluxKind.µ,T>,Function<? super T, ? extends Higher<FluxKind.µ,R>>,Higher<FluxKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<flux,T>,Function<? super T, ? extends Higher<flux,R>>,Higher<flux,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -651,10 +651,10 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<FluxKind.µ> monadZero(){
-            BiFunction<Higher<FluxKind.µ,T>,Predicate<? super T>,Higher<FluxKind.µ,T>> filter = Instances::filter;
-            Supplier<Higher<FluxKind.µ, T>> zero = ()-> FluxKind.widen(Flux.empty());
-            return General.<FluxKind.µ,T,R>monadZero(monad(), zero,filter);
+        public static <T,R> MonadZero<flux> monadZero(){
+            BiFunction<Higher<flux,T>,Predicate<? super T>,Higher<flux,T>> filter = Instances::filter;
+            Supplier<Higher<flux, T>> zero = ()-> FluxKind.widen(Flux.empty());
+            return General.<flux,T,R>monadZero(monad(), zero,filter);
         }
         /**
          * <pre>
@@ -668,9 +668,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Fluxs by concatenation
          */
-        public static <T> MonadPlus<FluxKind.µ> monadPlus(){
+        public static <T> MonadPlus<flux> monadPlus(){
             Monoid<FluxKind<T>> m = Monoid.of(FluxKind.widen(Flux.<T>empty()), Instances::concat);
-            Monoid<Higher<FluxKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<flux,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -689,15 +689,15 @@ public static class Instances {
          * @param m Monoid to use for combining Fluxs
          * @return Type class for combining Fluxs
          */
-        public static <T> MonadPlus<FluxKind.µ> monadPlus(Monoid<FluxKind<T>> m){
-            Monoid<Higher<FluxKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<flux> monadPlus(Monoid<FluxKind<T>> m){
+            Monoid<Higher<flux,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<FluxKind.µ> traverse(){
+        public static <C2,T> Traverse<flux> traverse(){
             BiFunction<Applicative<C2>,FluxKind<Higher<C2, T>>,Higher<C2, FluxKind<T>>> sequenceFn = (ap, flux) -> {
 
                 Higher<C2,FluxKind<T>> identity = ap.unit(FluxKind.widen(Flux.empty()));
@@ -712,7 +712,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<FluxKind.µ,Higher<C2, T>>,Higher<C2, Higher<FluxKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<flux,Higher<C2, T>>,Higher<C2, Higher<flux,T>>> sequenceNarrow  =
                     (a,b) -> FluxKind.widen2(sequenceFn.apply(a, FluxKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -732,9 +732,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<FluxKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<FluxKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(FluxKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<FluxKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(FluxKind.narrow(l)).reduce(m);
+        public static <T> Foldable<flux> foldable(){
+            BiFunction<Monoid<T>,Higher<flux,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(FluxKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<flux,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(FluxKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -747,13 +747,13 @@ private static <T> FluxKind<T> of(T value){
         private static <T,R> FluxKind<R> ap(FluxKind<Function< T, R>> lt, FluxKind<T> flux){
             return FluxKind.widen(lt.zipWith(flux,(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<FluxKind.µ,R> flatMap(Higher<FluxKind.µ,T> lt, Function<? super T, ? extends  Higher<FluxKind.µ,R>> fn){
+        private static <T,R> Higher<flux,R> flatMap(Higher<flux,T> lt, Function<? super T, ? extends  Higher<flux,R>> fn){
             return FluxKind.widen(FluxKind.narrowK(lt).flatMap(fn.andThen(FluxKind::narrowK)));
         }
         private static <T,R> FluxKind<R> map(FluxKind<T> lt, Function<? super T, ? extends R> fn){
             return FluxKind.widen(lt.map(fn));
         }
-        private static <T> FluxKind<T> filter(Higher<FluxKind.µ,T> lt, Predicate<? super T> fn){
+        private static <T> FluxKind<T> filter(Higher<flux,T> lt, Predicate<? super T> fn){
             return FluxKind.widen(FluxKind.narrow(lt).filter(fn));
         }
     }
diff --git a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
index ed370382..d2c05e8f 100644
--- a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
+++ b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
@@ -476,7 +476,7 @@ public static class Instances {
          *
          * @return A functor for Monos
          */
-        public static <T,R>Functor<MonoKind.µ> functor(){
+        public static <T,R>Functor<mono> functor(){
             BiFunction<MonoKind<T>,Function<? super T, ? extends R>,MonoKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -495,8 +495,8 @@ public static class Instances {
          *
          * @return A factory for Monos
          */
-        public static <T> Pure<MonoKind.µ> unit(){
-            return General.<MonoKind.µ,T>unit(Instances::of);
+        public static <T> Pure<mono> unit(){
+            return General.<mono,T>unit(Instances::of);
         }
         /**
          *
@@ -535,7 +535,7 @@ public static class Instances {
          *
          * @return A zipper for Monos
          */
-        public static <T,R> Applicative<MonoKind.µ> applicative(){
+        public static <T,R> Applicative<mono> applicative(){
             BiFunction<MonoKind< Function<T, R>>,MonoKind<T>,MonoKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -565,9 +565,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Monos
          */
-        public static <T,R> Monad<MonoKind.µ> monad(){
+        public static <T,R> Monad<mono> monad(){
 
-            BiFunction<Higher<MonoKind.µ,T>,Function<? super T, ? extends Higher<MonoKind.µ,R>>,Higher<MonoKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<mono,T>,Function<? super T, ? extends Higher<mono,R>>,Higher<mono,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -587,7 +587,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<MonoKind.µ> monadZero(){
+        public static <T,R> MonadZero<mono> monadZero(){
 
             return General.monadZero(monad(), MonoKind.empty());
         }
@@ -605,13 +605,13 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Monos by concatenation
          */
-        public static <T> MonadPlus<MonoKind.µ> monadPlus(){
+        public static <T> MonadPlus<mono> monadPlus(){
 
 
             Monoid<MonoKind<T>> m = Monoid.of(MonoKind.<T>widen(Mono.empty()),
                     (f,g)-> MonoKind.widen(Mono.first(f.narrow(),g.narrow())));
 
-            Monoid<Higher<MonoKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<mono,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -630,15 +630,15 @@ public static class Instances {
          * @param m Monoid to use for combining Monos
          * @return Type class for combining Monos
          */
-        public static <T> MonadPlus<MonoKind.µ> monadPlus(Monoid<MonoKind<T>> m){
-            Monoid<Higher<MonoKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<mono> monadPlus(Monoid<MonoKind<T>> m){
+            Monoid<Higher<mono,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<MonoKind.µ> traverse(){
+        public static <C2,T> Traverse<mono> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -658,13 +658,13 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<MonoKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<MonoKind.µ,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), MonoKind.narrow(l).block());
-            BiFunction<Monoid<T>,Higher<MonoKind.µ,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), MonoKind.narrow(l).block());
+        public static <T> Foldable<mono> foldable(){
+            BiFunction<Monoid<T>,Higher<mono,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), MonoKind.narrow(l).block());
+            BiFunction<Monoid<T>,Higher<mono,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), MonoKind.narrow(l).block());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<MonoKind.µ> comonad(){
-            Function<? super Higher<MonoKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(MonoKind::narrow).block();
+        public static <T> Comonad<mono> comonad(){
+            Function<? super Higher<mono, T>, ? extends T> extractFn = maybe -> maybe.convert(MonoKind::narrow).block();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -677,7 +677,7 @@ private static <T,R> MonoKind<R> ap(MonoKind<Function< T, R>> lt, MonoKind<T> li
             return MonoKind.widen(Monos.combine(lt.narrow(),list.narrow(), (a, b)->a.apply(b)));
 
         }
-        private static <T,R> Higher<MonoKind.µ,R> flatMap(Higher<MonoKind.µ,T> lt, Function<? super T, ? extends  Higher<MonoKind.µ,R>> fn){
+        private static <T,R> Higher<mono,R> flatMap(Higher<mono,T> lt, Function<? super T, ? extends  Higher<mono,R>> fn){
             return MonoKind.widen(MonoKind.narrow(lt).flatMap(fn.andThen(MonoKind::narrow)));
         }
         private static <T,R> MonoKind<R> map(MonoKind<T> lt, Function<? super T, ? extends R> fn){
@@ -685,8 +685,8 @@ private static <T,R> MonoKind<R> map(MonoKind<T> lt, Function<? super T, ? exten
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<MonoKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                            Higher<MonoKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<mono, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                            Higher<mono, T> ds){
             Mono<T> future = MonoKind.narrow(ds);
             return applicative.map(MonoKind::just, fn.apply(future.block()));
         }
diff --git a/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/FluxTest.java b/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/FluxTest.java
index 99370d92..a6d2243f 100644
--- a/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/FluxTest.java
+++ b/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/FluxTest.java
@@ -14,6 +14,8 @@
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Lambda;
+import cyclops.monads.ReactorWitness;
+import cyclops.monads.ReactorWitness.flux;
 import cyclops.stream.ReactiveSeq;
 import org.junit.Test;
 
@@ -36,7 +38,7 @@ public void functor(){
         
         FluxKind<Integer> list = Fluxs.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Fluxs.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Fluxs.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(FluxKind::narrowK);
         
         assertThat(list.collect(Collectors.toList()).block(),equalTo(Arrays.asList("hello".length())));
@@ -58,8 +60,8 @@ public void applicative(){
         
         FluxKind<Integer> list = Fluxs.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Fluxs.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Fluxs.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h-> Fluxs.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Fluxs.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(FluxKind::narrowK);
         
         assertThat(list.collect(Collectors.toList()).block(),equalTo(Arrays.asList("hello".length()*2)));
@@ -75,7 +77,7 @@ public void monad(){
         
         FluxKind<Integer> list = Fluxs.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Fluxs.Instances.monad().flatMap((String v) -> Fluxs.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Fluxs.Instances.monad().flatMap((String v) -> Fluxs.Instances.unit().unit(v.length()), h))
                                      .convert(FluxKind::narrowK);
         
         assertThat(list.collect(Collectors.toList()).block(),equalTo(Arrays.asList("hello".length())));
@@ -85,7 +87,7 @@ public void monadZeroFilter(){
         
         FluxKind<String> list = Fluxs.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Fluxs.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Fluxs.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(FluxKind::narrowK);
         
         assertThat(list.collect(Collectors.toList()).block(),equalTo(Arrays.asList("hello")));
@@ -95,7 +97,7 @@ public void monadZeroFilterOut(){
         
         FluxKind<String> list = Fluxs.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Fluxs.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Fluxs.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(FluxKind::narrowK);
         
         assertThat(list.collect(Collectors.toList()).block(),equalTo(Arrays.asList()));
@@ -136,7 +138,7 @@ public void  foldRight(){
     @Test
     public void traverse(){
 
-       Maybe<Higher<FluxKind.µ, Integer>> res = Fluxs.Instances.traverse()
+       Maybe<Higher<flux, Integer>> res = Fluxs.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), FluxKind.just(1,2,3))
                                                          .convert(Maybe::narrowK);
        
diff --git a/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java b/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java
index 4fbcc386..a94467d2 100644
--- a/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java
+++ b/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java
@@ -15,6 +15,10 @@
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Monoid;
+import cyclops.monads.ReactorWitness;
+import cyclops.monads.ReactorWitness.mono;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.maybe;
 import cyclops.typeclasses.monad.Applicative;
 import cyclops.typeclasses.monad.Traverse;
 import org.junit.Test;
@@ -38,7 +42,7 @@ public void functor(){
         
         MonoKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
                                      .convert(MonoKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()).join()));
@@ -58,8 +62,8 @@ public void applicative(){
         
         MonoKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Instances.applicative().ap(optFn, h))
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Instances.applicative().ap(optFn, h))
                                      .convert(MonoKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()*2).join()));
@@ -75,7 +79,7 @@ public void monad(){
         
         MonoKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monad().flatMap((String v) -> Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Instances.monad().flatMap((String v) -> Instances.unit().unit(v.length()), h))
                                      .convert(MonoKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()).join()));
@@ -85,7 +89,7 @@ public void monadZeroFilter(){
         
         MonoKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(MonoKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello").join()));
@@ -95,7 +99,7 @@ public void monadZeroFilterOut(){
         
         MonoKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(MonoKind::narrowK);
         
         assertTrue(opt.block()==null);
@@ -133,14 +137,14 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-        Traverse<MonoKind.µ> traverse = Monos.Instances.traverse();
-        Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
+        Traverse<mono> traverse = Monos.Instances.traverse();
+        Applicative<maybe> applicative = Maybe.Instances.applicative();
 
         MonoKind<Integer> mono = MonoKind.widen(Mono.just(1));
 
-        Higher<Maybe.µ, Higher<MonoKind.µ, Integer>> t = traverse.traverseA(applicative, (Integer a) -> Maybe.just(a * 2), mono);
+        Higher<maybe, Higher<mono, Integer>> t = traverse.traverseA(applicative, (Integer a) -> Maybe.just(a * 2), mono);
 
-        Maybe<Higher<MonoKind.µ, Integer>> res = traverse.traverseA(applicative, (Integer a)-> Maybe.just(a*2),mono)
+        Maybe<Higher<mono, Integer>> res = traverse.traverseA(applicative, (Integer a)-> Maybe.just(a*2),mono)
                                                         .convert(Maybe::narrowK);
 
 
@@ -150,10 +154,10 @@ public void traverse(){
     }
     @Test
     public void sequence(){
-        Traverse<MonoKind.µ> traverse = Monos.Instances.traverse();
-        Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
+        Traverse<mono> traverse = Monos.Instances.traverse();
+        Applicative<maybe> applicative = Maybe.Instances.applicative();
 
-        Higher<Maybe.µ, Higher<MonoKind.µ, Integer>> res = traverse.sequenceA(applicative, MonoKind.widen(Mono.just(Maybe.just(1))));
+        Higher<maybe, Higher<mono, Integer>> res = traverse.sequenceA(applicative, MonoKind.widen(Mono.just(Maybe.just(1))));
         Maybe<Mono<Integer>> nk = res.convert(Maybe::narrowK)
                                      .map(h -> h.convert(MonoKind::narrow));
 
diff --git a/cyclops-rx/readme.md b/cyclops-rx/readme.md
index d09e4b3a..30f7b66b 100644
--- a/cyclops-rx/readme.md
+++ b/cyclops-rx/readme.md
@@ -303,8 +303,8 @@ e.g. using the Pure and Functor typeclasses for Vavr Streams
 
 ```java
 
-Pure<ObservableKind.µ> pure = Observables.Instances.unit();
-Functor<ObservableKind.µ> functor = Observables.Instances.functor();
+Pure<observable> pure = Observables.Instances.unit();
+Functor<observable> functor = Observables.Instances.functor();
         
 ObservableKind<Integer> list = pure.unit("hello")
                                    .apply(h->functor.map((String v) ->v.length(), h))
diff --git a/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java b/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java
index 8759778a..a8830486 100644
--- a/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java
+++ b/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java
@@ -2,7 +2,7 @@
 
 
 import cyclops.companion.rx.Observables;
-import cyclops.monads.RxWitness.obsvervable;
+import cyclops.monads.RxWitness.observable;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
 import lombok.AllArgsConstructor;
@@ -14,19 +14,19 @@
 
 
 @AllArgsConstructor
-public class ObservableAdapter extends AbstractFunctionalAdapter<obsvervable> {
+public class ObservableAdapter extends AbstractFunctionalAdapter<observable> {
 
 
 
 
 
     @Override
-    public <T> Iterable<T> toIterable(AnyM<obsvervable, T> t) {
+    public <T> Iterable<T> toIterable(AnyM<observable, T> t) {
         return ()-> observable(t).toBlocking().toIterable().iterator();
     }
 
     @Override
-    public <T, R> AnyM<obsvervable, R> ap(AnyM<obsvervable,? extends Function<? super T,? extends R>> fn, AnyM<obsvervable, T> apply) {
+    public <T, R> AnyM<observable, R> ap(AnyM<observable,? extends Function<? super T,? extends R>> fn, AnyM<observable, T> apply) {
         Observable<T> f = observable(apply);
         Observable<? extends Function<? super T, ? extends R>> fnF = observable(fn);
         Observable<R> res = fnF.zipWith(f, (a, b) -> a.apply(b));
@@ -35,36 +35,36 @@ public <T, R> AnyM<obsvervable, R> ap(AnyM<obsvervable,? extends Function<? supe
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> filter(AnyM<obsvervable, T> t, Predicate<? super T> fn) {
+    public <T> AnyM<observable, T> filter(AnyM<observable, T> t, Predicate<? super T> fn) {
         return Observables.anyM(observable(t).filter(e->fn.test(e)));
     }
 
-    <T> Observable<T> observable(AnyM<obsvervable,T> anyM){
+    <T> Observable<T> observable(AnyM<observable,T> anyM){
         ObservableReactiveSeq<T> seq = anyM.unwrap();
         return seq.observable;
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> empty() {
+    public <T> AnyM<observable, T> empty() {
         return Observables.anyM(Observable.empty());
     }
 
 
 
     @Override
-    public <T, R> AnyM<obsvervable, R> flatMap(AnyM<obsvervable, T> t,
-                                     Function<? super T, ? extends AnyM<obsvervable, ? extends R>> fn) {
+    public <T, R> AnyM<observable, R> flatMap(AnyM<observable, T> t,
+                                              Function<? super T, ? extends AnyM<observable, ? extends R>> fn) {
         return Observables.anyM(observable(t).flatMap(x->observable(fn.apply(x))));
 
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> unitIterable(Iterable<T> it)  {
+    public <T> AnyM<observable, T> unitIterable(Iterable<T> it)  {
         return Observables.anyM(Observable.from(it));
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> unit(T o) {
+    public <T> AnyM<observable, T> unit(T o) {
         return Observables.anyM(Observable.just(o));
     }
 
diff --git a/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java b/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
index a3b170f5..fc9caf84 100644
--- a/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
+++ b/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
@@ -6,6 +6,8 @@
 import java.util.concurrent.TimeUnit;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.RxWitness;
+import cyclops.monads.RxWitness.observable;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
@@ -40,7 +42,7 @@
 /**
  * Simulates Higher Kinded Types for Reactor Observable's
  * 
- * ObservableKind is a Observable and a Higher Kinded Type (ObservableKind.µ,T)
+ * ObservableKind is a Observable and a Higher Kinded Type (observable,T)
  * 
  * @author johnmcclean
  *
@@ -48,7 +50,7 @@
  */
 
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final class ObservableKind<T> implements Higher<ObservableKind.µ, T>, Publisher<T> {
+public final class ObservableKind<T> implements Higher<observable, T>, Publisher<T> {
 
     /**
      * Witness type
@@ -100,7 +102,7 @@ public static <T> ObservableKind<T> widen(final Observable<T> observable) {
      * @param flux HTK encoded type containing  a Observable to widen
      * @return HKT encoded type with a widened Observable
      */
-    public static <C2, T> Higher<C2, Higher<ObservableKind.µ, T>> widen2(Higher<C2, ObservableKind<T>> flux) {
+    public static <C2, T> Higher<C2, Higher<observable, T>> widen2(Higher<C2, ObservableKind<T>> flux) {
         // a functor could be used (if C2 is a functor / one exists for C2 type)
         // instead of casting
         // cast seems safer as Higher<StreamType.µ,T> must be a StreamType
@@ -119,7 +121,7 @@ public static <T> ObservableKind<T> widen(final Publisher<T> completableObservab
      * @param future HKT encoded list into a ObservableKind
      * @return ObservableKind
      */
-    public static <T> ObservableKind<T> narrowK(final Higher<ObservableKind.µ, T> future) {
+    public static <T> ObservableKind<T> narrowK(final Higher<observable, T> future) {
         return (ObservableKind<T>) future;
     }
 
@@ -129,7 +131,7 @@ public static <T> ObservableKind<T> narrowK(final Higher<ObservableKind.µ, T> f
      * @param observable Type Constructor to convert back into narrowed type
      * @return Observable from Higher Kinded Type
      */
-    public static <T> Observable<T> narrow(final Higher<ObservableKind.µ, T> observable) {
+    public static <T> Observable<T> narrow(final Higher<observable, T> observable) {
 
         return ((ObservableKind<T>) observable).narrow();
 
diff --git a/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java b/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java
index fb707181..5cd592fc 100644
--- a/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java
+++ b/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java
@@ -1,18 +1,13 @@
 package cyclops.companion.rx;
 
-import java.util.*;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.function.*;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
 import com.aol.cyclops.rx.adapter.ObservableReactiveSeq;
-import com.aol.cyclops2.internal.stream.ReactiveStreamX;
-import com.aol.cyclops2.types.reactive.AsyncSubscriber;
 import cyclops.monads.RxWitness;
-import cyclops.monads.RxWitness.obsvervable;
+import cyclops.monads.RxWitness.observable;
 import com.aol.cyclops.rx.hkt.ObservableKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
@@ -35,15 +30,8 @@
 import org.reactivestreams.Publisher;
 import rx.*;
 import rx.Observable;
-import rx.Observer;
-import rx.annotations.Beta;
-import rx.annotations.Experimental;
-import rx.exceptions.Exceptions;
 import rx.functions.*;
 import rx.internal.operators.*;
-import rx.internal.util.RxRingBuffer;
-import rx.internal.util.ScalarSynchronousObservable;
-import rx.internal.util.UtilityFunctions;
 import rx.observables.AsyncOnSubscribe;
 import rx.observables.SyncOnSubscribe;
 import rx.schedulers.Schedulers;
@@ -60,7 +48,7 @@ public class Observables {
     public static <T,W extends WitnessType<W>> AnyM<W,Observable<T>> fromStream(AnyM<W,Stream<T>> anyM){
         return anyM.map(s->fromStream(s));
     }
-    public static <T> Observable<T> raw(AnyM<obsvervable,T> anyM){
+    public static <T> Observable<T> raw(AnyM<observable,T> anyM){
         return RxWitness.observable(anyM);
     }
     public static <T> Observable<T> narrow(Observable<? extends T> observable) {
@@ -386,8 +374,8 @@ public static ReactiveSeq<Long> timer(long delay, TimeUnit unit, Scheduler sched
      * @param obs Observable to wrap inside an AnyM
      * @return AnyMSeq wrapping an Observable
      */
-    public static <T> AnyMSeq<obsvervable,T> anyM(Observable<T> obs) {
-        return AnyM.ofSeq(reactiveSeq(obs), obsvervable.INSTANCE);
+    public static <T> AnyMSeq<observable,T> anyM(Observable<T> obs) {
+        return AnyM.ofSeq(reactiveSeq(obs), observable.INSTANCE);
     }
 
     /**
@@ -688,7 +676,7 @@ public static class Instances {
          *
          * @return A functor for Observables
          */
-        public static <T,R>Functor<ObservableKind.µ> functor(){
+        public static <T,R>Functor<observable> functor(){
             BiFunction<ObservableKind<T>,Function<? super T, ? extends R>,ObservableKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -707,8 +695,8 @@ public static class Instances {
          *
          * @return A factory for Observables
          */
-        public static <T> Pure<ObservableKind.µ> unit(){
-            return General.<ObservableKind.µ,T>unit(Instances::of);
+        public static <T> Pure<observable> unit(){
+            return General.<observable,T>unit(Instances::of);
         }
         /**
          *
@@ -746,7 +734,7 @@ public static class Instances {
          *
          * @return A zipper for Observables
          */
-        public static <T,R> Applicative<ObservableKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<observable> zippingApplicative(){
             BiFunction<ObservableKind< Function<T, R>>,ObservableKind<T>,ObservableKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -776,9 +764,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Observables
          */
-        public static <T,R> Monad<ObservableKind.µ> monad(){
+        public static <T,R> Monad<observable> monad(){
 
-            BiFunction<Higher<ObservableKind.µ,T>,Function<? super T, ? extends Higher<ObservableKind.µ,R>>,Higher<ObservableKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<observable,T>,Function<? super T, ? extends Higher<observable,R>>,Higher<observable,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -798,10 +786,10 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<ObservableKind.µ> monadZero(){
-            BiFunction<Higher<ObservableKind.µ,T>,Predicate<? super T>,Higher<ObservableKind.µ,T>> filter = Instances::filter;
-            Supplier<Higher<ObservableKind.µ, T>> zero = ()-> ObservableKind.widen(Observable.empty());
-            return General.<ObservableKind.µ,T,R>monadZero(monad(), zero,filter);
+        public static <T,R> MonadZero<observable> monadZero(){
+            BiFunction<Higher<observable,T>,Predicate<? super T>,Higher<observable,T>> filter = Instances::filter;
+            Supplier<Higher<observable, T>> zero = ()-> ObservableKind.widen(Observable.empty());
+            return General.<observable,T,R>monadZero(monad(), zero,filter);
         }
         /**
          * <pre>
@@ -815,9 +803,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Observables by concatenation
          */
-        public static <T> MonadPlus<ObservableKind.µ> monadPlus(){
+        public static <T> MonadPlus<observable> monadPlus(){
             Monoid<ObservableKind<T>> m = Monoid.of(ObservableKind.widen(Observable.<T>empty()), Instances::concat);
-            Monoid<Higher<ObservableKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -836,15 +824,15 @@ public static class Instances {
          * @param m Monoid to use for combining Observables
          * @return Type class for combining Observables
          */
-        public static <T> MonadPlus<ObservableKind.µ> monadPlus(Monoid<ObservableKind<T>> m){
-            Monoid<Higher<ObservableKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<observable> monadPlus(Monoid<ObservableKind<T>> m){
+            Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<ObservableKind.µ> traverse(){
+        public static <C2,T> Traverse<observable> traverse(){
             BiFunction<Applicative<C2>,ObservableKind<Higher<C2, T>>,Higher<C2, ObservableKind<T>>> sequenceFn = (ap, observable) -> {
 
                 Higher<C2,ObservableKind<T>> identity = ap.unit(ObservableKind.widen(Observable.empty()));
@@ -859,7 +847,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<ObservableKind.µ,Higher<C2, T>>,Higher<C2, Higher<ObservableKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<observable,Higher<C2, T>>,Higher<C2, Higher<observable,T>>> sequenceNarrow  =
                     (a,b) -> ObservableKind.widen2(sequenceFn.apply(a, ObservableKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -879,9 +867,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<ObservableKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<ObservableKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<ObservableKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).reduce(m);
+        public static <T> Foldable<observable> foldable(){
+            BiFunction<Monoid<T>,Higher<observable,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<observable,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -894,7 +882,7 @@ private <T> ObservableKind<T> of(T value){
         private static <T,R> ObservableKind<R> ap(ObservableKind<Function< T, R>> lt, ObservableKind<T> observable){
             return ObservableKind.widen(lt.zipWith(observable.narrow(),(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<ObservableKind.µ,R> flatMap(Higher<ObservableKind.µ,T> lt, Function<? super T, ? extends  Higher<ObservableKind.µ,R>> fn){
+        private static <T,R> Higher<observable,R> flatMap(Higher<observable,T> lt, Function<? super T, ? extends  Higher<observable,R>> fn){
             Func1<? super T, ? extends  Observable<R>> f = t->fn.andThen(ObservableKind::narrow).apply(t);
 
             return ObservableKind.widen(ObservableKind.narrowK(lt)
@@ -903,7 +891,7 @@ private static <T,R> ObservableKind<R> ap(ObservableKind<Function< T, R>> lt, Ob
         private static <T,R> ObservableKind<R> map(ObservableKind<T> lt, Function<? super T, ? extends R> fn){
             return ObservableKind.widen(lt.map(in->fn.apply(in)));
         }
-        private static <T> ObservableKind<T> filter(Higher<ObservableKind.µ,T> lt, Predicate<? super T> fn){
+        private static <T> ObservableKind<T> filter(Higher<observable,T> lt, Predicate<? super T> fn){
             return ObservableKind.widen(ObservableKind.narrow(lt).filter(in->fn.test(in)));
         }
     }
diff --git a/cyclops-rx/src/main/java/cyclops/monads/RxWitness.java b/cyclops-rx/src/main/java/cyclops/monads/RxWitness.java
index 3b69862a..d11defda 100644
--- a/cyclops-rx/src/main/java/cyclops/monads/RxWitness.java
+++ b/cyclops-rx/src/main/java/cyclops/monads/RxWitness.java
@@ -10,7 +10,7 @@
 
 public interface RxWitness {
 
-    public static <T> Observable<T> observable(AnyM<obsvervable,? extends T> anyM){
+    public static <T> Observable<T> observable(AnyM<observable,? extends T> anyM){
         ObservableReactiveSeq<T> obs = anyM.unwrap();
         return obs.getObservable();
     }
@@ -18,11 +18,11 @@ public static <T> Observable<T> observable(AnyM<obsvervable,? extends T> anyM){
     static interface ObservableWitness<W extends RxWitness.ObservableWitness<W>>  extends WitnessType<W> {
 
     }
-    public static enum obsvervable implements ObservableWitness<obsvervable> {
+    public static enum observable implements ObservableWitness<observable> {
         INSTANCE;
 
         @Override
-        public FunctionalAdapter<obsvervable> adapter() {
+        public FunctionalAdapter<observable> adapter() {
             return new ObservableAdapter();
         }
 
diff --git a/cyclops-rx/src/test/java/com/aol/cyclops/rx/RxTest.java b/cyclops-rx/src/test/java/com/aol/cyclops/rx/RxTest.java
index 8bc975b3..7cadc409 100644
--- a/cyclops-rx/src/test/java/com/aol/cyclops/rx/RxTest.java
+++ b/cyclops-rx/src/test/java/com/aol/cyclops/rx/RxTest.java
@@ -5,19 +5,16 @@
 import static org.hamcrest.Matchers.equalTo;
 import static org.junit.Assert.assertThat;
 
-import com.aol.cyclops.rx.adapter.ObservableReactiveSeq;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
-import cyclops.monads.RxWitness.obsvervable;
+import cyclops.monads.RxWitness.observable;
 
 import cyclops.collections.mutable.ListX;
 import cyclops.companion.rx.Observables;
-import cyclops.monads.RxWitness;
 import cyclops.stream.ReactiveSeq;
 import cyclops.stream.Spouts;
 import org.junit.Test;
 
 
-import reactor.core.publisher.Flux;
 import rx.Observable;
 
 import java.util.concurrent.Executors;
@@ -61,7 +58,7 @@ public void anyMAsync(){
 
         ReactiveSeq<Integer> asyncSeq = Spouts.async(Stream.of(1, 2, 3), Executors.newFixedThreadPool(1));
         Observable<Integer> observableAsync = Observables.observableFrom(asyncSeq);
-        AnyMSeq<obsvervable,Integer> monad = Observables.anyM(observableAsync);
+        AnyMSeq<observable,Integer> monad = Observables.anyM(observableAsync);
 
         monad.map(i->i*2)
                 .forEach(System.out::println,System.err::println,()->complete.set(true));
diff --git a/cyclops-rx/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java b/cyclops-rx/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java
index fb8d8bc1..0494cc88 100644
--- a/cyclops-rx/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java
+++ b/cyclops-rx/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java
@@ -14,6 +14,10 @@
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Lambda;
+import cyclops.monads.RxWitness;
+import cyclops.monads.RxWitness.observable;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.maybe;
 import cyclops.stream.ReactiveSeq;
 import org.junit.Test;
 
@@ -39,7 +43,7 @@ public void functor(){
         
         ObservableKind<Integer> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Observables.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length())));
@@ -59,8 +63,8 @@ public void applicative(){
         
         ObservableKind<Integer> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h->Observables.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h->Observables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Observables.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length()*2)));
@@ -76,7 +80,7 @@ public void monad(){
         
         ObservableKind<Integer> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.monad().flatMap((String v) ->Observables.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h->Observables.Instances.monad().flatMap((String v) ->Observables.Instances.unit().unit(v.length()), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length())));
@@ -86,7 +90,7 @@ public void monadZeroFilter(){
         
         ObservableKind<String> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h->Observables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello")));
@@ -96,7 +100,7 @@ public void monadZeroFilterOut(){
         
         ObservableKind<String> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h->Observables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList()));
@@ -109,17 +113,7 @@ public void monadPlus(){
                                       .convert(ObservableKind::narrowK);
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList(10)));
     }
-/**
-    @Test
-    public void monadPlusNonEmpty(){
-        
-        Monoid<ObservableKind<Integer>> m = Monoid.of(ObservableKind.widen(Observable.empty()), (a,b)->a.isEmpty() ? b : a);
-        ObservableKind<Integer> list = ObservableInstances.<Integer>monadPlus(m)
-                                      .plus(ObservableKind.widen(Observable.of(5)), ObservableKind.widen(Observable.of(10)))
-                                      .convert(ObservableKind::narrowK);
-        assertThat(list,equalTo(Arrays.asList(5)));
-    }
-**/
+
     @Test
     public void  foldLeft(){
         int sum  = Observables.Instances.foldable()
@@ -136,10 +130,10 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-        Function<Integer,Higher<Maybe.µ,Integer>> fn = (Integer a) -> Maybe.<Integer>just(a * 2);
-        Higher<Maybe.µ, Higher<ObservableKind.µ, Integer>> one = Observables.Instances.traverse()
+        Function<Integer,Higher<maybe,Integer>> fn = (Integer a) -> Maybe.<Integer>just(a * 2);
+        Higher<maybe, Higher<observable, Integer>> one = Observables.Instances.traverse()
                 .traverseA(Maybe.Instances.applicative(), fn, ObservableKind.just(1, 2, 3));
-       Maybe<Higher<ObservableKind.µ, Integer>> res = Observables.Instances.traverse()
+       Maybe<Higher<observable, Integer>> res = Observables.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), ObservableKind.just(1,2,3))
                                                          .convert(Maybe::narrowK);
        
diff --git a/cyclops-rxjava2/readme.md b/cyclops-rxjava2/readme.md
index 1704d52c..5e48f095 100644
--- a/cyclops-rxjava2/readme.md
+++ b/cyclops-rxjava2/readme.md
@@ -475,8 +475,8 @@ e.g. using the Pure and Functor typeclasses for Vavr Streams
 
 ```java
 
-Pure<ObservableKind.µ> pure = Observables.Instances.unit();
-Functor<ObservableKind.µ> functor = Observables.Instances.functor();
+Pure<observable> pure = Observables.Instances.unit();
+Functor<observable> functor = Observables.Instances.functor();
         
 ObservableKind<Integer> list = pure.unit("hello")
                                    .apply(h->functor.map((String v) ->v.length(), h))
@@ -496,20 +496,20 @@ SingleKind<Integer> single = SingleKind.widen(Single.just(1));
 SingleKind implements the Higher interface which captures that our type is both a Single and takes a data type of Integer
 
 ```java
-Higher<SingleKind.µ, Integer> higher = single;
+Higher<single, Integer> higher = single;
 ```
 
 We can use the Traverse and Applicative typeclasses to sequence a Single with a (cyclops-react) Maybe into a Maybe with a Single.
 ```java
-Traverse<SingleKind.µ> traverse = Singles.Instances.traverse();
+Traverse<single> traverse = Singles.Instances.traverse();
 Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
 ```
 
 ```java
-Traverse<SingleKind.µ> traverse = Singles.Instances.traverse();        
+Traverse<single> traverse = Singles.Instances.traverse();        
 Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
         
-Higher<Maybe.µ, Higher<SingleKind.µ, Integer>> result = traverse.sequenceA(applicative, SingleKind.widen(Single.just(Maybe.just(1))));
+Higher<Maybe.µ, Higher<single, Integer>> result = traverse.sequenceA(applicative, SingleKind.widen(Single.just(Maybe.just(1))));
 ```
 Our result is a little ugly - we should convert it back into a more readable form.
 
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java
index ba197f25..ca7b6119 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java
@@ -2,7 +2,7 @@
 
 
 import cyclops.companion.rx2.Observables;
-import cyclops.monads.Rx2Witness.obsvervable;
+import cyclops.monads.Rx2Witness.observable;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
 import lombok.AllArgsConstructor;
@@ -14,19 +14,19 @@
 
 
 @AllArgsConstructor
-public class ObservableAdapter extends AbstractFunctionalAdapter<obsvervable> {
+public class ObservableAdapter extends AbstractFunctionalAdapter<observable> {
 
 
 
 
 
     @Override
-    public <T> Iterable<T> toIterable(AnyM<obsvervable, T> t) {
+    public <T> Iterable<T> toIterable(AnyM<observable, T> t) {
         return ()-> observable(t).blockingIterable().iterator();
     }
 
     @Override
-    public <T, R> AnyM<obsvervable, R> ap(AnyM<obsvervable,? extends Function<? super T,? extends R>> fn, AnyM<obsvervable, T> apply) {
+    public <T, R> AnyM<observable, R> ap(AnyM<observable,? extends Function<? super T,? extends R>> fn, AnyM<observable, T> apply) {
         Observable<T> f = observable(apply);
         Observable<? extends Function<? super T, ? extends R>> fnF = observable(fn);
         Observable<R> res = fnF.zipWith(f, (a, b) -> a.apply(b));
@@ -35,36 +35,36 @@ public <T, R> AnyM<obsvervable, R> ap(AnyM<obsvervable,? extends Function<? supe
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> filter(AnyM<obsvervable, T> t, Predicate<? super T> fn) {
+    public <T> AnyM<observable, T> filter(AnyM<observable, T> t, Predicate<? super T> fn) {
         return Observables.anyM(observable(t).filter(e->fn.test(e)));
     }
 
-    <T> Observable<T> observable(AnyM<obsvervable,T> anyM){
+    <T> Observable<T> observable(AnyM<observable,T> anyM){
         ObservableReactiveSeq<T> seq = anyM.unwrap();
         return seq.observable;
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> empty() {
+    public <T> AnyM<observable, T> empty() {
         return Observables.anyM(Observable.empty());
     }
 
 
 
     @Override
-    public <T, R> AnyM<obsvervable, R> flatMap(AnyM<obsvervable, T> t,
-                                     Function<? super T, ? extends AnyM<obsvervable, ? extends R>> fn) {
+    public <T, R> AnyM<observable, R> flatMap(AnyM<observable, T> t,
+                                              Function<? super T, ? extends AnyM<observable, ? extends R>> fn) {
         return Observables.anyM(observable(t).flatMap(x->observable(fn.apply(x))));
 
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> unitIterable(Iterable<T> it)  {
+    public <T> AnyM<observable, T> unitIterable(Iterable<T> it)  {
         return Observables.anyM(Observable.fromIterable(it));
     }
 
     @Override
-    public <T> AnyM<obsvervable, T> unit(T o) {
+    public <T> AnyM<observable, T> unit(T o) {
         return Observables.anyM(Observable.just(o));
     }
 
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java
index 28d4e9f4..64b5e0f0 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java
@@ -2,6 +2,8 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.flowable;
 import cyclops.stream.ReactiveSeq;
 import io.reactivex.*;
 import io.reactivex.Observable;
@@ -40,7 +42,7 @@
 /**
  * Simulates Higher Kinded Types for Reactor Flowable's
  * 
- * FlowableKind is a Flowable and a Higher Kinded Type (FlowableKind.µ,T)
+ * FlowableKind is a Flowable and a Higher Kinded Type (flowable,T)
  * 
  * @author johnmcclean
  *
@@ -48,7 +50,7 @@
  */
 
 
-public final class FlowableKind<T> implements Higher<FlowableKind.µ, T>, Publisher<T> {
+public final class FlowableKind<T> implements Higher<flowable, T>, Publisher<T> {
 
     private FlowableKind(Flowable<T> boxed) {
         this.boxed = boxed;
@@ -64,14 +66,7 @@ public Flowable<T> narrow() {
         return boxed;
     }
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+
     
     /**
      * Construct a HKT encoded completed Flowable
@@ -112,7 +107,7 @@ public static <T> FlowableKind<T> widen(final Flowable<T> completableFlowable) {
      * @param flux HTK encoded type containing  a Flowable to widen
      * @return HKT encoded type with a widened Flowable
      */
-    public static <C2,T> Higher<C2, Higher<FlowableKind.µ,T>> widen2(Higher<C2, FlowableKind<T>> flux){
+    public static <C2,T> Higher<C2, Higher<flowable,T>> widen2(Higher<C2, FlowableKind<T>> flux){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
         //cast seems safer as Higher<StreamType.µ,T> must be a StreamType
         return (Higher)flux;
@@ -130,7 +125,7 @@ public static <T> FlowableKind<T> widen(final Publisher<T> completableFlowable)
      * @param future HKT encoded list into a FlowableKind
      * @return FlowableKind
      */
-    public static <T> FlowableKind<T> narrowK(final Higher<FlowableKind.µ, T> future) {
+    public static <T> FlowableKind<T> narrowK(final Higher<flowable, T> future) {
        return (FlowableKind<T>)future;
     }
 
@@ -140,7 +135,7 @@ public static <T> FlowableKind<T> narrowK(final Higher<FlowableKind.µ, T> futur
      * @param completableFlowable Type Constructor to convert back into narrowed type
      * @return Flowable from Higher Kinded Type
      */
-    public static <T> Flowable<T> narrow(final Higher<FlowableKind.µ, T> completableFlowable) {
+    public static <T> Flowable<T> narrow(final Higher<flowable, T> completableFlowable) {
       
             return ((FlowableKind<T>)completableFlowable).narrow();
            
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java
index d3725a3f..1675c859 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java
@@ -4,6 +4,8 @@
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.async.Future;
 import cyclops.companion.rx2.Maybes;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.maybe;
 import io.reactivex.*;
 import io.reactivex.annotations.*;
 import io.reactivex.disposables.Disposable;
@@ -18,7 +20,7 @@
 /**
  * Simulates Higher Kinded Types for RxJava 2 Maybe's
  * 
- * MaybeKind is a Maybe and a Higher Kinded Type (MaybeKind.µ,T)
+ * MaybeKind is a Maybe and a Higher Kinded Type (maybe,T)
  * 
  * @author johnmcclean
  *
@@ -26,19 +28,12 @@
  */
 
 
-public final class MaybeKind<T> implements Higher<MaybeKind.µ, T>, Publisher<T> {
+public final class MaybeKind<T> implements Higher<maybe, T>, Publisher<T> {
     private MaybeKind(Maybe<T> boxed) {
         this.boxed = boxed;
     }
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+
     
     /**
      * Construct a HKT encoded completed Maybe
@@ -83,7 +78,7 @@ public static <T> MaybeKind<T> widen(final Publisher<T> completableMaybe) {
      * @param future HKT encoded list into a MaybeKind
      * @return MaybeKind
      */
-    public static <T> MaybeKind<T> narrowK(final Higher<MaybeKind.µ, T> future) {
+    public static <T> MaybeKind<T> narrowK(final Higher<maybe, T> future) {
        return (MaybeKind<T>)future;
     }
 
@@ -93,7 +88,7 @@ public static <T> MaybeKind<T> narrowK(final Higher<MaybeKind.µ, T> future) {
      * @param completableMaybe Type Constructor to convert back into narrowed type
      * @return Maybe from Higher Kinded Type
      */
-    public static <T> Maybe<T> narrow(final Higher<MaybeKind.µ, T> completableMaybe) {
+    public static <T> Maybe<T> narrow(final Higher<maybe, T> completableMaybe) {
       
             return ((MaybeKind<T>)completableMaybe).narrow();
            
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java
index 5e25163d..aa89f6c9 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java
@@ -9,6 +9,8 @@
 import java.util.concurrent.TimeUnit;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.observable;
 import io.reactivex.*;
 import io.reactivex.annotations.*;
 import io.reactivex.disposables.Disposable;
@@ -29,7 +31,7 @@
 /**
  * Simulates Higher Kinded Types for Reactor Observable's
  * 
- * ObservableKind is a Observable and a Higher Kinded Type (ObservableKind.µ,T)
+ * ObservableKind is a Observable and a Higher Kinded Type (observable,T)
  * 
  * @author johnmcclean
  *
@@ -37,16 +39,7 @@
  */
 
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final class ObservableKind<T> implements Higher<ObservableKind.µ, T>, Publisher<T> {
-
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+public final class ObservableKind<T> implements Higher<observable, T>, Publisher<T> {
 
     /**
      * Construct a HKT encoded completed Observable
@@ -89,7 +82,7 @@ public static <T> ObservableKind<T> widen(final Observable<T> observable) {
      * @param flux HTK encoded type containing  a Observable to widen
      * @return HKT encoded type with a widened Observable
      */
-    public static <C2, T> Higher<C2, Higher<µ, T>> widen2(Higher<C2, ObservableKind<T>> flux) {
+    public static <C2, T> Higher<C2, Higher<observable, T>> widen2(Higher<C2, ObservableKind<T>> flux) {
         // a functor could be used (if C2 is a functor / one exists for C2 type)
         // instead of casting
         // cast seems safer as Higher<StreamType.µ,T> must be a StreamType
@@ -108,7 +101,7 @@ public static <T> ObservableKind<T> widen(final Publisher<T> completableObservab
      * @param future HKT encoded list into a ObservableKind
      * @return ObservableKind
      */
-    public static <T> ObservableKind<T> narrowK(final Higher<µ, T> future) {
+    public static <T> ObservableKind<T> narrowK(final Higher<observable, T> future) {
         return (ObservableKind<T>) future;
     }
 
@@ -118,7 +111,7 @@ public static <T> ObservableKind<T> narrowK(final Higher<µ, T> future) {
      * @param observable Type Constructor to convert back into narrowed type
      * @return Observable from Higher Kinded Type
      */
-    public static <T> Observable<T> narrow(final Higher<µ, T> observable) {
+    public static <T> Observable<T> narrow(final Higher<observable, T> observable) {
 
         return ((ObservableKind<T>) observable).narrow();
 
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java
index 87e0e348..a7c21dba 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java
@@ -3,6 +3,8 @@
 
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.async.Future;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.single;
 import io.reactivex.*;
 import io.reactivex.annotations.*;
 import io.reactivex.disposables.Disposable;
@@ -29,7 +31,7 @@
 /**
  * Simulates Higher Kinded Types for RxJava 2 Single's
  * 
- * SingleKind is a Single and a Higher Kinded Type (SingleKind.µ,T)
+ * SingleKind is a Single and a Higher Kinded Type (single,T)
  * 
  * @author johnmcclean
  *
@@ -37,7 +39,7 @@
  */
 
 
-public final class SingleKind<T> implements Higher<SingleKind.µ, T>, Publisher<T> {
+public final class SingleKind<T> implements Higher<single, T>, Publisher<T> {
     private SingleKind(Single<T> boxed) {
         this.boxed = boxed;
     }
@@ -94,7 +96,7 @@ public static <T> SingleKind<T> widen(final Publisher<T> completableSingle) {
      * @param future HKT encoded list into a SingleKind
      * @return SingleKind
      */
-    public static <T> SingleKind<T> narrowK(final Higher<SingleKind.µ, T> future) {
+    public static <T> SingleKind<T> narrowK(final Higher<single, T> future) {
        return (SingleKind<T>)future;
     }
 
@@ -104,7 +106,7 @@ public static <T> SingleKind<T> narrowK(final Higher<SingleKind.µ, T> future) {
      * @param completableSingle Type Constructor to convert back into narrowed type
      * @return Single from Higher Kinded Type
      */
-    public static <T> Single<T> narrow(final Higher<SingleKind.µ, T> completableSingle) {
+    public static <T> Single<T> narrow(final Higher<single, T> completableSingle) {
             return ((SingleKind<T>)completableSingle).narrow();
     }
 
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java
index 5e777c55..917af553 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java
@@ -500,7 +500,7 @@ public static class Instances {
          *
          * @return A functor for Flowables
          */
-        public static <T,R>Functor<FlowableKind.µ> functor(){
+        public static <T,R>Functor<flowable> functor(){
             BiFunction<FlowableKind<T>,Function<? super T, ? extends R>,FlowableKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -519,9 +519,9 @@ public static class Instances {
          *
          * @return A factory for Flowables
          */
-        public static <T> Pure<FlowableKind.µ> unit(){
-            Function<T, Higher<FlowableKind.µ, T>> unitRef = Instances::of;
-            return General.<FlowableKind.µ,T>unit(unitRef);
+        public static <T> Pure<flowable> unit(){
+            Function<T, Higher<flowable, T>> unitRef = Instances::of;
+            return General.<flowable,T>unit(unitRef);
         }
         /**
          *
@@ -559,7 +559,7 @@ public static class Instances {
          *
          * @return A zipper for Flowables
          */
-        public static <T,R> Applicative<FlowableKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<flowable> zippingApplicative(){
             BiFunction<FlowableKind< Function<T, R>>,FlowableKind<T>,FlowableKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -589,9 +589,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Flowables
          */
-        public static <T,R> Monad<FlowableKind.µ> monad(){
+        public static <T,R> Monad<flowable> monad(){
 
-            BiFunction<Higher<FlowableKind.µ,T>,Function<? super T, ? extends Higher<FlowableKind.µ,R>>,Higher<FlowableKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<flowable,T>,Function<? super T, ? extends Higher<flowable,R>>,Higher<flowable,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -611,10 +611,10 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<FlowableKind.µ> monadZero(){
-            BiFunction<Higher<FlowableKind.µ,T>,Predicate<? super T>,Higher<FlowableKind.µ,T>> filter = Instances::filter;
-            Supplier<Higher<FlowableKind.µ, T>> zero = ()-> FlowableKind.widen(Flowable.empty());
-            return General.<FlowableKind.µ,T,R>monadZero(monad(), zero,filter);
+        public static <T,R> MonadZero<flowable> monadZero(){
+            BiFunction<Higher<flowable,T>,Predicate<? super T>,Higher<flowable,T>> filter = Instances::filter;
+            Supplier<Higher<flowable, T>> zero = ()-> FlowableKind.widen(Flowable.empty());
+            return General.<flowable,T,R>monadZero(monad(), zero,filter);
         }
         /**
          * <pre>
@@ -628,9 +628,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Flowables by concatenation
          */
-        public static <T> MonadPlus<FlowableKind.µ> monadPlus(){
+        public static <T> MonadPlus<flowable> monadPlus(){
             Monoid<FlowableKind<T>> m = Monoid.of(FlowableKind.widen(Flowable.<T>empty()), Instances::concat);
-            Monoid<Higher<FlowableKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<flowable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -649,15 +649,15 @@ public static class Instances {
          * @param m Monoid to use for combining Flowables
          * @return Type class for combining Flowables
          */
-        public static <T> MonadPlus<FlowableKind.µ> monadPlus(Monoid<FlowableKind<T>> m){
-            Monoid<Higher<FlowableKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<flowable> monadPlus(Monoid<FlowableKind<T>> m){
+            Monoid<Higher<flowable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<FlowableKind.µ> traverse(){
+        public static <C2,T> Traverse<flowable> traverse(){
             BiFunction<Applicative<C2>,FlowableKind<Higher<C2, T>>,Higher<C2, FlowableKind<T>>> sequenceFn = (ap, flowable) -> {
 
                 Higher<C2,FlowableKind<T>> identity = ap.unit(FlowableKind.widen(Flowable.empty()));
@@ -672,7 +672,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<FlowableKind.µ,Higher<C2, T>>,Higher<C2, Higher<FlowableKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<flowable,Higher<C2, T>>,Higher<C2, Higher<flowable,T>>> sequenceNarrow  =
                     (a,b) -> FlowableKind.widen2(sequenceFn.apply(a, FlowableKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -692,9 +692,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<FlowableKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<FlowableKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(FlowableKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<FlowableKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(FlowableKind.narrow(l)).reduce(m);
+        public static <T> Foldable<flowable> foldable(){
+            BiFunction<Monoid<T>,Higher<flowable,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(FlowableKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<flowable,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(FlowableKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -707,13 +707,13 @@ private static <T> FlowableKind<T> of(T value){
         private static <T,R> FlowableKind<R> ap(FlowableKind<Function< T, R>> lt, FlowableKind<T> flowable){
             return FlowableKind.widen(lt.zipWith(flowable,(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<FlowableKind.µ,R> flatMap(Higher<FlowableKind.µ,T> lt, Function<? super T, ? extends  Higher<FlowableKind.µ,R>> fn){
+        private static <T,R> Higher<flowable,R> flatMap(Higher<flowable,T> lt, Function<? super T, ? extends  Higher<flowable,R>> fn){
             return FlowableKind.widen(FlowableKind.narrowK(lt).flatMap(Functions.rxFunction(fn.andThen(FlowableKind::narrowK))));
         }
         private static <T,R> FlowableKind<R> map(FlowableKind<T> lt, Function<? super T, ? extends R> fn){
             return FlowableKind.widen(lt.map(Functions.rxFunction(fn)));
         }
-        private static <T> FlowableKind<T> filter(Higher<FlowableKind.µ,T> lt, Predicate<? super T> fn){
+        private static <T> FlowableKind<T> filter(Higher<flowable,T> lt, Predicate<? super T> fn){
             return FlowableKind.widen(FlowableKind.narrow(lt).filter(Functions.rxPredicate(fn)));
         }
     }
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
index 7be282fa..495d10ed 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
@@ -491,7 +491,7 @@ public static class Instances {
          *
          * @return A functor for Maybes
          */
-        public static <T,R>Functor<MaybeKind.µ> functor(){
+        public static <T,R>Functor<maybe> functor(){
             BiFunction<MaybeKind<T>,Function<? super T, ? extends R>,MaybeKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -510,8 +510,8 @@ public static class Instances {
          *
          * @return A factory for Maybes
          */
-        public static <T> Pure<MaybeKind.µ> unit(){
-            return General.<MaybeKind.µ,T>unit(Instances::of);
+        public static <T> Pure<maybe> unit(){
+            return General.<maybe,T>unit(Instances::of);
         }
         /**
          *
@@ -550,7 +550,7 @@ public static class Instances {
          *
          * @return A zipper for Maybes
          */
-        public static <T,R> Applicative<MaybeKind.µ> applicative(){
+        public static <T,R> Applicative<maybe> applicative(){
             BiFunction<MaybeKind< Function<T, R>>,MaybeKind<T>,MaybeKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -580,9 +580,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Maybes
          */
-        public static <T,R> Monad<MaybeKind.µ> monad(){
+        public static <T,R> Monad<maybe> monad(){
 
-            BiFunction<Higher<MaybeKind.µ,T>,Function<? super T, ? extends Higher<MaybeKind.µ,R>>,Higher<MaybeKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<maybe,T>,Function<? super T, ? extends Higher<maybe,R>>,Higher<maybe,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -602,7 +602,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<MaybeKind.µ> monadZero(){
+        public static <T,R> MonadZero<maybe> monadZero(){
 
             return General.monadZero(monad(), MaybeKind.empty());
         }
@@ -620,13 +620,13 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Maybes by concatenation
          */
-        public static <T> MonadPlus<MaybeKind.µ> monadPlus(){
+        public static <T> MonadPlus<maybe> monadPlus(){
 
 
             Monoid<MaybeKind<T>> m = Monoid.of(MaybeKind.<T>widen(Maybe.empty()),
                     (f,g)-> MaybeKind.widen(Maybe.ambArray(f.narrow(),g.narrow())));
 
-            Monoid<Higher<MaybeKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<maybe,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -645,15 +645,15 @@ public static class Instances {
          * @param m Monoid to use for combining Maybes
          * @return Type class for combining Maybes
          */
-        public static <T> MonadPlus<MaybeKind.µ> monadPlus(Monoid<MaybeKind<T>> m){
-            Monoid<Higher<MaybeKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<maybe> monadPlus(Monoid<MaybeKind<T>> m){
+            Monoid<Higher<maybe,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<MaybeKind.µ> traverse(){
+        public static <C2,T> Traverse<maybe> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -673,13 +673,13 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<MaybeKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<MaybeKind.µ,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), MaybeKind.narrow(l).blockingGet());
-            BiFunction<Monoid<T>,Higher<MaybeKind.µ,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), MaybeKind.narrow(l).blockingGet());
+        public static <T> Foldable<maybe> foldable(){
+            BiFunction<Monoid<T>,Higher<maybe,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), MaybeKind.narrow(l).blockingGet());
+            BiFunction<Monoid<T>,Higher<maybe,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), MaybeKind.narrow(l).blockingGet());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<MaybeKind.µ> comonad(){
-            Function<? super Higher<MaybeKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(MaybeKind::narrow).blockingGet();
+        public static <T> Comonad<maybe> comonad(){
+            Function<? super Higher<maybe, T>, ? extends T> extractFn = maybe -> maybe.convert(MaybeKind::narrow).blockingGet();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -692,7 +692,7 @@ private static <T,R> MaybeKind<R> ap(MaybeKind<Function< T, R>> lt, MaybeKind<T>
             return MaybeKind.widen(Maybes.combine(lt.narrow(),list.narrow(), (a, b)->a.apply(b)));
 
         }
-        private static <T,R> Higher<MaybeKind.µ,R> flatMap(Higher<MaybeKind.µ,T> lt, Function<? super T, ? extends  Higher<MaybeKind.µ,R>> fn){
+        private static <T,R> Higher<maybe,R> flatMap(Higher<maybe,T> lt, Function<? super T, ? extends  Higher<maybe,R>> fn){
             return MaybeKind.widen(MaybeKind.narrow(lt).flatMap(Functions.rxFunction(fn.andThen(MaybeKind::narrow))));
         }
         private static <T,R> MaybeKind<R> map(MaybeKind<T> lt, Function<? super T, ? extends R> fn){
@@ -700,8 +700,8 @@ private static <T,R> MaybeKind<R> map(MaybeKind<T> lt, Function<? super T, ? ext
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<MaybeKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                            Higher<MaybeKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<maybe, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                            Higher<maybe, T> ds){
             Maybe<T> future = MaybeKind.narrow(ds);
             return applicative.map(MaybeKind::just, fn.apply(future.blockingGet()));
         }
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java
index 7707a2ef..93192ac9 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java
@@ -7,7 +7,7 @@
 
 import com.aol.cyclops.rx2.adapter.ObservableReactiveSeq;
 import cyclops.monads.Rx2Witness;
-import cyclops.monads.Rx2Witness.obsvervable;
+import cyclops.monads.Rx2Witness.observable;
 import com.aol.cyclops.rx2.hkt.ObservableKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
@@ -30,8 +30,6 @@
 import io.reactivex.schedulers.Schedulers;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-
 
 
 /**
@@ -46,7 +44,7 @@ public class Observables {
     public static <T,W extends WitnessType<W>> AnyM<W,Observable<T>> fromStream(AnyM<W,Stream<T>> anyM){
         return anyM.map(s->fromStream(s));
     }
-    public static <T> Observable<T> raw(AnyM<obsvervable,T> anyM){
+    public static <T> Observable<T> raw(AnyM<observable,T> anyM){
         return Rx2Witness.observable(anyM);
     }
     public static <T> Observable<T> narrow(Observable<? extends T> observable) {
@@ -317,8 +315,8 @@ public static ReactiveSeq<Long> timer(long delay, TimeUnit unit, Scheduler sched
      * @param obs Observable to wrap inside an AnyM
      * @return AnyMSeq wrapping an Observable
      */
-    public static <T> AnyMSeq<obsvervable,T> anyM(Observable<T> obs) {
-        return AnyM.ofSeq(reactiveSeq(obs), obsvervable.INSTANCE);
+    public static <T> AnyMSeq<observable,T> anyM(Observable<T> obs) {
+        return AnyM.ofSeq(reactiveSeq(obs), observable.INSTANCE);
     }
 
     /**
@@ -619,7 +617,7 @@ public static class Instances {
          *
          * @return A functor for Observables
          */
-        public static <T,R>Functor<ObservableKind.µ> functor(){
+        public static <T,R>Functor<observable> functor(){
             BiFunction<ObservableKind<T>,Function<? super T, ? extends R>,ObservableKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -638,8 +636,8 @@ public static class Instances {
          *
          * @return A factory for Observables
          */
-        public static <T> Pure<ObservableKind.µ> unit(){
-            return General.<ObservableKind.µ,T>unit(Instances::of);
+        public static <T> Pure<observable> unit(){
+            return General.<observable,T>unit(Instances::of);
         }
         /**
          *
@@ -677,7 +675,7 @@ public static class Instances {
          *
          * @return A zipper for Observables
          */
-        public static <T,R> Applicative<ObservableKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<observable> zippingApplicative(){
             BiFunction<ObservableKind< Function<T, R>>,ObservableKind<T>,ObservableKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -707,9 +705,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Observables
          */
-        public static <T,R> Monad<ObservableKind.µ> monad(){
+        public static <T,R> Monad<observable> monad(){
 
-            BiFunction<Higher<ObservableKind.µ,T>,Function<? super T, ? extends Higher<ObservableKind.µ,R>>,Higher<ObservableKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<observable,T>,Function<? super T, ? extends Higher<observable,R>>,Higher<observable,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -729,10 +727,10 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<ObservableKind.µ> monadZero(){
-            BiFunction<Higher<ObservableKind.µ,T>,Predicate<? super T>,Higher<ObservableKind.µ,T>> filter = Instances::filter;
-            Supplier<Higher<ObservableKind.µ, T>> zero = ()-> ObservableKind.widen(Observable.empty());
-            return General.<ObservableKind.µ,T,R>monadZero(monad(), zero,filter);
+        public static <T,R> MonadZero<observable> monadZero(){
+            BiFunction<Higher<observable,T>,Predicate<? super T>,Higher<observable,T>> filter = Instances::filter;
+            Supplier<Higher<observable, T>> zero = ()-> ObservableKind.widen(Observable.empty());
+            return General.<observable,T,R>monadZero(monad(), zero,filter);
         }
         /**
          * <pre>
@@ -746,9 +744,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Observables by concatenation
          */
-        public static <T> MonadPlus<ObservableKind.µ> monadPlus(){
+        public static <T> MonadPlus<observable> monadPlus(){
             Monoid<ObservableKind<T>> m = Monoid.of(ObservableKind.widen(Observable.<T>empty()), Instances::concat);
-            Monoid<Higher<ObservableKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -767,15 +765,15 @@ public static class Instances {
          * @param m Monoid to use for combining Observables
          * @return Type class for combining Observables
          */
-        public static <T> MonadPlus<ObservableKind.µ> monadPlus(Monoid<ObservableKind<T>> m){
-            Monoid<Higher<ObservableKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<observable> monadPlus(Monoid<ObservableKind<T>> m){
+            Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<ObservableKind.µ> traverse(){
+        public static <C2,T> Traverse<observable> traverse(){
             BiFunction<Applicative<C2>,ObservableKind<Higher<C2, T>>,Higher<C2, ObservableKind<T>>> sequenceFn = (ap, observable) -> {
 
                 Higher<C2,ObservableKind<T>> identity = ap.unit(ObservableKind.widen(Observable.empty()));
@@ -790,7 +788,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<ObservableKind.µ,Higher<C2, T>>,Higher<C2, Higher<ObservableKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<observable,Higher<C2, T>>,Higher<C2, Higher<observable,T>>> sequenceNarrow  =
                     (a,b) -> ObservableKind.widen2(sequenceFn.apply(a, ObservableKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -810,9 +808,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<ObservableKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<ObservableKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<ObservableKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).reduce(m);
+        public static <T> Foldable<observable> foldable(){
+            BiFunction<Monoid<T>,Higher<observable,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<observable,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromPublisher(ObservableKind.narrowK(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -825,7 +823,7 @@ private <T> ObservableKind<T> of(T value){
         private static <T,R> ObservableKind<R> ap(ObservableKind<Function< T, R>> lt, ObservableKind<T> observable){
             return ObservableKind.widen(lt.zipWith(observable.narrow(),(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<ObservableKind.µ,R> flatMap(Higher<ObservableKind.µ,T> lt, Function<? super T, ? extends  Higher<ObservableKind.µ,R>> fn){
+        private static <T,R> Higher<observable,R> flatMap(Higher<observable,T> lt, Function<? super T, ? extends  Higher<observable,R>> fn){
             io.reactivex.functions.Function<? super T, ? extends  Observable<R>> f = t->fn.andThen(ObservableKind::narrow).apply(t);
 
             return ObservableKind.widen(ObservableKind.narrowK(lt)
@@ -834,7 +832,7 @@ private static <T,R> ObservableKind<R> ap(ObservableKind<Function< T, R>> lt, Ob
         private static <T,R> ObservableKind<R> map(ObservableKind<T> lt, Function<? super T, ? extends R> fn){
             return ObservableKind.widen(lt.map(in->fn.apply(in)));
         }
-        private static <T> ObservableKind<T> filter(Higher<ObservableKind.µ,T> lt, Predicate<? super T> fn){
+        private static <T> ObservableKind<T> filter(Higher<observable,T> lt, Predicate<? super T> fn){
             return ObservableKind.widen(ObservableKind.narrow(lt).filter(in->fn.test(in)));
         }
     }
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java
index 637002ee..3c18ca3f 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java
@@ -479,7 +479,7 @@ public static class Instances {
          *
          * @return A functor for Singles
          */
-        public static <T,R>Functor<SingleKind.µ> functor(){
+        public static <T,R>Functor<single> functor(){
             BiFunction<SingleKind<T>,Function<? super T, ? extends R>,SingleKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -498,8 +498,8 @@ public static class Instances {
          *
          * @return A factory for Singles
          */
-        public static <T> Pure<SingleKind.µ> unit(){
-            return General.<SingleKind.µ,T>unit(Instances::of);
+        public static <T> Pure<single> unit(){
+            return General.<single,T>unit(Instances::of);
         }
         /**
          *
@@ -538,7 +538,7 @@ public static class Instances {
          *
          * @return A zipper for Singles
          */
-        public static <T,R> Applicative<SingleKind.µ> applicative(){
+        public static <T,R> Applicative<single> applicative(){
             BiFunction<SingleKind< Function<T, R>>,SingleKind<T>,SingleKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -568,9 +568,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Singles
          */
-        public static <T,R> Monad<SingleKind.µ> monad(){
+        public static <T,R> Monad<single> monad(){
 
-            BiFunction<Higher<SingleKind.µ,T>,Function<? super T, ? extends Higher<SingleKind.µ,R>>,Higher<SingleKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<single,T>,Function<? super T, ? extends Higher<single,R>>,Higher<single,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -590,7 +590,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<SingleKind.µ> monadZero(){
+        public static <T,R> MonadZero<single> monadZero(){
 
             return General.monadZero(monad(), SingleKind.empty());
         }
@@ -608,13 +608,13 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Singles by concatenation
          */
-        public static <T> MonadPlus<SingleKind.µ> monadPlus(){
+        public static <T> MonadPlus<single> monadPlus(){
 
 
             Monoid<SingleKind<T>> m = Monoid.of(SingleKind.<T>widen(Single.never()),
                     (f,g)-> SingleKind.widen(Single.ambArray(f.narrow(),g.narrow())));
 
-            Monoid<Higher<SingleKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<single,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -633,15 +633,15 @@ public static class Instances {
          * @param m Monoid to use for combining Singles
          * @return Type class for combining Singles
          */
-        public static <T> MonadPlus<SingleKind.µ> monadPlus(Monoid<SingleKind<T>> m){
-            Monoid<Higher<SingleKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<single> monadPlus(Monoid<SingleKind<T>> m){
+            Monoid<Higher<single,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<SingleKind.µ> traverse(){
+        public static <C2,T> Traverse<single> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -661,13 +661,13 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<SingleKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<SingleKind.µ,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), SingleKind.narrow(l).blockingGet());
-            BiFunction<Monoid<T>,Higher<SingleKind.µ,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), SingleKind.narrow(l).blockingGet());
+        public static <T> Foldable<single> foldable(){
+            BiFunction<Monoid<T>,Higher<single,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), SingleKind.narrow(l).blockingGet());
+            BiFunction<Monoid<T>,Higher<single,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), SingleKind.narrow(l).blockingGet());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<SingleKind.µ> comonad(){
-            Function<? super Higher<SingleKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(SingleKind::narrow).blockingGet();
+        public static <T> Comonad<single> comonad(){
+            Function<? super Higher<single, T>, ? extends T> extractFn = maybe -> maybe.convert(SingleKind::narrow).blockingGet();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -680,7 +680,7 @@ private static <T,R> SingleKind<R> ap(SingleKind<Function< T, R>> lt, SingleKind
             return SingleKind.widen(Singles.combine(lt.narrow(),list.narrow(), (a, b)->a.apply(b)));
 
         }
-        private static <T,R> Higher<SingleKind.µ,R> flatMap(Higher<SingleKind.µ,T> lt, Function<? super T, ? extends  Higher<SingleKind.µ,R>> fn){
+        private static <T,R> Higher<single,R> flatMap(Higher<single,T> lt, Function<? super T, ? extends  Higher<single,R>> fn){
             return SingleKind.widen(SingleKind.narrow(lt).flatMap(Functions.rxFunction(fn.andThen(SingleKind::narrow))));
         }
         private static <T,R> SingleKind<R> map(SingleKind<T> lt, Function<? super T, ? extends R> fn){
@@ -688,8 +688,8 @@ private static <T,R> SingleKind<R> map(SingleKind<T> lt, Function<? super T, ? e
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<SingleKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                            Higher<SingleKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<single, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                            Higher<single, T> ds){
             Single<T> future = SingleKind.narrow(ds);
             return applicative.map(SingleKind::just, fn.apply(future.blockingGet()));
         }
diff --git a/cyclops-rxjava2/src/main/java/cyclops/monads/Rx2Witness.java b/cyclops-rxjava2/src/main/java/cyclops/monads/Rx2Witness.java
index bc75e322..7a8000f1 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/monads/Rx2Witness.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/monads/Rx2Witness.java
@@ -64,7 +64,7 @@ public FunctionalAdapter<single> adapter() {
     }
 
 
-    public static <T> Observable<T> observable(AnyM<obsvervable, ? extends T> anyM){
+    public static <T> Observable<T> observable(AnyM<observable, ? extends T> anyM){
         ObservableReactiveSeq<T> obs = anyM.unwrap();
         return obs.getObservable();
     }
@@ -72,11 +72,11 @@ public static <T> Observable<T> observable(AnyM<obsvervable, ? extends T> anyM){
     static interface ObservableWitness<W extends ObservableWitness<W>>  extends WitnessType<W> {
 
     }
-    public static enum obsvervable implements ObservableWitness<obsvervable> {
+    public static enum observable implements ObservableWitness<observable> {
         INSTANCE;
 
         @Override
-        public FunctionalAdapter<obsvervable> adapter() {
+        public FunctionalAdapter<observable> adapter() {
             return new ObservableAdapter();
         }
 
diff --git a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/RxTest.java b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/RxTest.java
index ab11c8dd..00090f4e 100644
--- a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/RxTest.java
+++ b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/RxTest.java
@@ -6,7 +6,7 @@
 import static org.junit.Assert.assertThat;
 
 import com.aol.cyclops2.types.anyM.AnyMSeq;
-import cyclops.monads.Rx2Witness.obsvervable;
+import cyclops.monads.Rx2Witness.observable;
 
 import cyclops.collections.mutable.ListX;
 import cyclops.companion.rx2.Observables;
@@ -61,7 +61,7 @@ public void anyMAsync(){
 
         ReactiveSeq<Integer> asyncSeq = Spouts.async(Stream.of(1, 2, 3), Executors.newFixedThreadPool(1));
         Observable<Integer> observableAsync = Observables.observableFrom(asyncSeq);
-        AnyMSeq<obsvervable,Integer> monad = Observables.anyM(observableAsync);
+        AnyMSeq<observable,Integer> monad = Observables.anyM(observableAsync);
 
         monad.map(i->i*2)
                 .forEach(System.out::println,System.err::println,()->complete.set(true));
diff --git a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/FlowableTest.java b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/FlowableTest.java
index d3cb9c1b..b9f432bb 100644
--- a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/FlowableTest.java
+++ b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/FlowableTest.java
@@ -7,6 +7,8 @@
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Lambda;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.flowable;
 import cyclops.stream.ReactiveSeq;
 import io.reactivex.Flowable;
 import org.junit.Test;
@@ -35,7 +37,7 @@ public void functor(){
         
         FlowableKind<Integer> list = Flowables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Flowables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Flowables.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(FlowableKind::narrowK);
         
         assertThat(Flowables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length())));
@@ -55,8 +57,8 @@ public void applicative(){
         
         FlowableKind<Integer> list = Flowables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Flowables.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h->Flowables.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h->Flowables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Flowables.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(FlowableKind::narrowK);
         
         assertThat(Flowables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length()*2)));
@@ -72,7 +74,7 @@ public void monad(){
         
         FlowableKind<Integer> list = Flowables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Flowables.Instances.monad().flatMap((String v) ->Flowables.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h->Flowables.Instances.monad().flatMap((String v) ->Flowables.Instances.unit().unit(v.length()), h))
                                      .convert(FlowableKind::narrowK);
         
         assertThat(Flowables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length())));
@@ -82,7 +84,7 @@ public void monadZeroFilter(){
         
         FlowableKind<String> list = Flowables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Flowables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h->Flowables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(FlowableKind::narrowK);
         
         assertThat(Flowables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello")));
@@ -92,7 +94,7 @@ public void monadZeroFilterOut(){
         
         FlowableKind<String> list = Flowables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Flowables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h->Flowables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(FlowableKind::narrowK);
         
         assertThat(Flowables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList()));
@@ -105,17 +107,7 @@ public void monadPlus(){
                                       .convert(FlowableKind::narrowK);
         assertThat(Flowables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList(10)));
     }
-/**
-    @Test
-    public void monadPlusNonEmpty(){
-        
-        Monoid<FlowableKind<Integer>> m = Monoid.of(FlowableKind.widen(Flowable.empty()), (a,b)->a.isEmpty() ? b : a);
-        FlowableKind<Integer> list = FlowableInstances.<Integer>monadPlus(m)
-                                      .plus(FlowableKind.widen(Flowable.of(5)), FlowableKind.widen(Flowable.of(10)))
-                                      .convert(FlowableKind::narrowK);
-        assertThat(list,equalTo(Arrays.asList(5)));
-    }
-**/
+
     @Test
     public void  foldLeft(){
         int sum  = Flowables.Instances.foldable()
@@ -134,7 +126,7 @@ public void  foldRight(){
     public void traverse(){
 
 
-        Maybe<Higher<FlowableKind.µ, Integer>> res = Flowables.Instances.traverse()
+        Maybe<Higher<flowable, Integer>> res = Flowables.Instances.traverse()
                                                                  .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), FlowableKind.just(1,2,3))
                                                                 .convert(Maybe::narrowK);
        
diff --git a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java
index 957eca96..6ef2f915 100644
--- a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java
+++ b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java
@@ -7,6 +7,9 @@
 
 import cyclops.function.Fn1;
 import cyclops.function.Monoid;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.maybe;
+import cyclops.monads.Witness;
 import cyclops.typeclasses.monad.Applicative;
 import cyclops.typeclasses.monad.Traverse;
 import io.reactivex.Maybe;
@@ -34,7 +37,7 @@ public void functor(){
         
         MaybeKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
                                      .convert(MaybeKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()).join()));
@@ -54,8 +57,8 @@ public void applicative(){
         
         MaybeKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Instances.applicative().ap(optFn, h))
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Instances.applicative().ap(optFn, h))
                                      .convert(MaybeKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()*2).join()));
@@ -71,7 +74,7 @@ public void monad(){
         
         MaybeKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monad().flatMap((String v) -> Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Instances.monad().flatMap((String v) -> Instances.unit().unit(v.length()), h))
                                      .convert(MaybeKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()).join()));
@@ -81,7 +84,7 @@ public void monadZeroFilter(){
         
         MaybeKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(MaybeKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello").join()));
@@ -91,7 +94,7 @@ public void monadZeroFilterOut(){
         
         MaybeKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(MaybeKind::narrowK);
         
         assertTrue(opt.blockingGet()==null);
@@ -129,14 +132,14 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-        Traverse<MaybeKind.µ> traverse = Instances.traverse();
-        Applicative<cyclops.control.Maybe.µ> applicative = cyclops.control.Maybe.Instances.applicative();
+        Traverse<maybe> traverse = Instances.traverse();
+        Applicative<Witness.maybe> applicative = cyclops.control.Maybe.Instances.applicative();
 
         MaybeKind<Integer> mono = widen(Maybe.just(1));
 
-        Higher<cyclops.control.Maybe.µ, Higher<MaybeKind.µ, Integer>> t = traverse.traverseA(applicative, (Integer a) -> cyclops.control.Maybe.just(a * 2), mono);
+        Higher<Witness.maybe, Higher<maybe, Integer>> t = traverse.traverseA(applicative, (Integer a) -> cyclops.control.Maybe.just(a * 2), mono);
 
-        cyclops.control.Maybe<Higher<MaybeKind.µ, Integer>> res = traverse.traverseA(applicative, (Integer a)-> cyclops.control.Maybe.just(a*2),mono)
+        cyclops.control.Maybe<Higher<maybe, Integer>> res = traverse.traverseA(applicative, (Integer a)-> cyclops.control.Maybe.just(a*2),mono)
                                                         .convert(cyclops.control.Maybe::narrowK);
 
 
@@ -147,10 +150,10 @@ public void traverse(){
     }
     @Test
     public void sequence(){
-        Traverse<MaybeKind.µ> traverse = Instances.traverse();
-        Applicative<cyclops.control.Maybe.µ> applicative = cyclops.control.Maybe.Instances.applicative();
+        Traverse<maybe> traverse = Instances.traverse();
+        Applicative<Witness.maybe> applicative = cyclops.control.Maybe.Instances.applicative();
 
-        Higher<cyclops.control.Maybe.µ, Higher<MaybeKind.µ, Integer>> res = traverse.sequenceA(applicative, widen(cyclops.control.Maybe.just(cyclops.control.Maybe.just(1))));
+        Higher<Witness.maybe, Higher<maybe, Integer>> res = traverse.sequenceA(applicative, widen(cyclops.control.Maybe.just(cyclops.control.Maybe.just(1))));
         cyclops.control.Maybe<Maybe<Integer>> nk = res.convert(cyclops.control.Maybe::narrowK)
                                      .map(h -> h.convert(MaybeKind::narrow));
 
diff --git a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java
index 1ea580a9..b53ec45d 100644
--- a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java
+++ b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/ObservableTest.java
@@ -14,6 +14,8 @@
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Lambda;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.observable;
 import cyclops.stream.ReactiveSeq;
 import io.reactivex.Observable;
 import org.junit.Test;
@@ -39,7 +41,7 @@ public void functor(){
         
         ObservableKind<Integer> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Observables.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length())));
@@ -59,8 +61,8 @@ public void applicative(){
         
         ObservableKind<Integer> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h->Observables.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h->Observables.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Observables.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length()*2)));
@@ -76,7 +78,7 @@ public void monad(){
         
         ObservableKind<Integer> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.monad().flatMap((String v) ->Observables.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h->Observables.Instances.monad().flatMap((String v) ->Observables.Instances.unit().unit(v.length()), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello".length())));
@@ -86,7 +88,7 @@ public void monadZeroFilter(){
         
         ObservableKind<String> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h->Observables.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList("hello")));
@@ -96,7 +98,7 @@ public void monadZeroFilterOut(){
         
         ObservableKind<String> list = Observables.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Observables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h->Observables.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(ObservableKind::narrowK);
         
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList()));
@@ -109,17 +111,7 @@ public void monadPlus(){
                                       .convert(ObservableKind::narrowK);
         assertThat(Observables.reactiveSeq(list.narrow()).toList(),equalTo(Arrays.asList(10)));
     }
-/**
-    @Test
-    public void monadPlusNonEmpty(){
-        
-        Monoid<ObservableKind<Integer>> m = Monoid.of(ObservableKind.widen(Observable.empty()), (a,b)->a.isEmpty() ? b : a);
-        ObservableKind<Integer> list = ObservableInstances.<Integer>monadPlus(m)
-                                      .plus(ObservableKind.widen(Observable.of(5)), ObservableKind.widen(Observable.of(10)))
-                                      .convert(ObservableKind::narrowK);
-        assertThat(list,equalTo(Arrays.asList(5)));
-    }
-**/
+
     @Test
     public void  foldLeft(){
         int sum  = Observables.Instances.foldable()
@@ -138,7 +130,7 @@ public void  foldRight(){
     public void traverse(){
 
 
-        Maybe<Higher<ObservableKind.µ, Integer>> res = Observables.Instances.traverse()
+        Maybe<Higher<observable, Integer>> res = Observables.Instances.traverse()
                                                                  .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), ObservableKind.just(1,2,3))
                                                                 .convert(Maybe::narrowK);
        
diff --git a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java
index d959c548..d5e5dd47 100644
--- a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java
+++ b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java
@@ -10,6 +10,10 @@
 import cyclops.function.Fn1;
 
 import cyclops.function.Monoid;
+import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.single;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.maybe;
 import cyclops.stream.ReactiveSeq;
 import cyclops.stream.Spouts;
 import cyclops.typeclasses.monad.Applicative;
@@ -43,7 +47,7 @@ public void functor(){
         
         SingleKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
                                      .convert(SingleKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()).join()));
@@ -63,8 +67,8 @@ public void applicative(){
         
         SingleKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Instances.applicative().ap(optFn, h))
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Instances.applicative().ap(optFn, h))
                                      .convert(SingleKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()*2).join()));
@@ -80,7 +84,7 @@ public void monad(){
         
         SingleKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monad().flatMap((String v) -> Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Instances.monad().flatMap((String v) -> Instances.unit().unit(v.length()), h))
                                      .convert(SingleKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello".length()).join()));
@@ -90,7 +94,7 @@ public void monadZeroFilter(){
         
         SingleKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(SingleKind::narrowK);
         
         assertThat(opt.toFuture().join(),equalTo(Future.ofResult("hello").join()));
@@ -100,7 +104,7 @@ public void monadZeroFilterOut(){
         
         SingleKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(SingleKind::narrowK);
 
         ReactiveSeq<String> f = Spouts.from(opt.narrow().toFlowable());
@@ -143,14 +147,14 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-        Traverse<SingleKind.µ> traverse = Instances.traverse();
-        Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
+        Traverse<single> traverse = Instances.traverse();
+        Applicative<maybe> applicative = Maybe.Instances.applicative();
 
         SingleKind<Integer> mono = widen(Single.just(1));
 
-        Higher<Maybe.µ, Higher<SingleKind.µ, Integer>> t = traverse.traverseA(applicative, (Integer a) -> Maybe.just(a * 2), mono);
+        Higher<maybe, Higher<single, Integer>> t = traverse.traverseA(applicative, (Integer a) -> Maybe.just(a * 2), mono);
 
-        Maybe<Higher<SingleKind.µ, Integer>> res = traverse.traverseA(applicative, (Integer a)-> Maybe.just(a*2),mono)
+        Maybe<Higher<single, Integer>> res = traverse.traverseA(applicative, (Integer a)-> Maybe.just(a*2),mono)
                                                         .convert(Maybe::narrowK);
 
 
@@ -160,10 +164,10 @@ public void traverse(){
     }
     @Test
     public void sequence(){
-        Traverse<SingleKind.µ> traverse = Instances.traverse();
-        Applicative<Maybe.µ> applicative = Maybe.Instances.applicative();
+        Traverse<single> traverse = Instances.traverse();
+        Applicative<maybe> applicative = Maybe.Instances.applicative();
 
-        Higher<Maybe.µ, Higher<SingleKind.µ, Integer>> res = traverse.sequenceA(applicative, widen(Single.just(Maybe.just(1))));
+        Higher<maybe, Higher<single, Integer>> res = traverse.sequenceA(applicative, widen(Single.just(Maybe.just(1))));
         Maybe<Single<Integer>> nk = res.convert(Maybe::narrowK)
                                      .map(h -> h.convert(SingleKind::narrow));
 
diff --git a/cyclops-vavr/readme.md b/cyclops-vavr/readme.md
index 9afa44ee..256584ee 100644
--- a/cyclops-vavr/readme.md
+++ b/cyclops-vavr/readme.md
@@ -201,8 +201,8 @@ e.g. using the Pure and Functor typeclasses for Vavr Streams
 
 ```java
 
-   Pure<StreamKind.µ> pure = Streams.Instances.unit();
-   Functor<StreamKind.µ> functor = Streams.Instances.functor();
+   Pure<stream> pure = Streams.Instances.unit();
+   Functor<stream> functor = Streams.Instances.functor();
         
    StreamKind<Integer> list = pure.unit("hello")
                                   .apply(h->functor.map((String v) ->v.length(), h))
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
index 068ef331..02e0dfaf 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
@@ -2,6 +2,8 @@
 
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.Unwrapable;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.array;
 import io.vavr.collection.Array;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -10,22 +12,15 @@
 /**
  * Simulates Higher Kinded Types for Array's
  * 
- * ArrayKind is a Array and a Higher Kinded Type (ArrayKind.µ,T)
+ * ArrayKind is a Array and a Higher Kinded Type (array,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the Array
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public  class ArrayKind<T> implements Higher<ArrayKind.µ, T>{
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+public  class ArrayKind<T> implements Higher<array, T>{
+
 
     public static <T> ArrayKind<T> of(T element) {
         return  widen(Array.of(element));
@@ -56,9 +51,9 @@ public static <T> ArrayKind<T> widen(final Array<T> list) {
      * @param list HTK encoded type containing  a Array to widen
      * @return HKT encoded type with a widened Array
      */
-    public static <C2,T> Higher<C2, Higher<ArrayKind.µ,T>> widen2(Higher<C2, ArrayKind<T>> list){
+    public static <C2,T> Higher<C2, Higher<array,T>> widen2(Higher<C2, ArrayKind<T>> list){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<ArrayKind.µ,T> must be a ArrayKind
+        //cast seems safer as Higher<array,T> must be a ArrayKind
         return (Higher)list;
     }
     /**
@@ -67,7 +62,7 @@ public static <T> ArrayKind<T> widen(final Array<T> list) {
      * @param list HKT encoded list into a ArrayKind
      * @return ArrayKind
      */
-    public static <T> ArrayKind<T> narrowK(final Higher<ArrayKind.µ, T> list) {
+    public static <T> ArrayKind<T> narrowK(final Higher<array, T> list) {
        return (ArrayKind<T>)list;
     }
     /**
@@ -76,7 +71,7 @@ public static <T> ArrayKind<T> narrowK(final Higher<ArrayKind.µ, T> list) {
      * @param list Type Constructor to convert back into narrowed type
      * @return ArrayX from Higher Kinded Type
      */
-    public static <T> Array<T> narrow(final Higher<ArrayKind.µ, T> list) {
+    public static <T> Array<T> narrow(final Higher<array, T> list) {
         return ((ArrayKind)list).narrow();
        
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
index 108d82fd..a78a66cd 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
@@ -11,6 +11,8 @@
 
 import com.aol.cyclops2.hkt.Higher;
 
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.future;
 import io.vavr.concurrent.Future;
 import io.vavr.concurrent.Promise;
 import io.vavr.control.Option;
@@ -21,23 +23,16 @@
 /**
  * Simulates Higher Kinded Types for Vavr Future's
  * 
- * FutureKind is a Future and a Higher Kinded Type (FutureKind.µ,T)
+ * FutureKind is a Future and a Higher Kinded Type (future,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the Future
  */
 
-public interface FutureKind<T> extends Higher<FutureKind.µ, T>, Future<T> {
+public interface FutureKind<T> extends Higher<future, T>, Future<T> {
+
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
     
     public static <T> FutureKind<T> failed(Throwable exception){
         return widen(Future.failed(exception));
@@ -82,7 +77,7 @@ public static <T> FutureKind<T> promise(){
      * @param future HKT encoded list into a FutureKind
      * @return FutureKind
      */
-    public static <T> FutureKind<T> narrowK(final Higher<FutureKind.µ, T> future) {
+    public static <T> FutureKind<T> narrowK(final Higher<future, T> future) {
        return (FutureKind<T>)future;
     }
 
@@ -92,7 +87,7 @@ public static <T> FutureKind<T> narrowK(final Higher<FutureKind.µ, T> future) {
      * @param completableFuture Type Constructor to convert back into narrowed type
      * @return Future from Higher Kinded Type
      */
-    public static <T> Future<T> narrow(final Higher<FutureKind.µ, T> completableFuture) {
+    public static <T> Future<T> narrow(final Higher<future, T> completableFuture) {
         if (completableFuture instanceof Future) {
             return (Future)completableFuture;
            
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
index 40559158..faa97546 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
@@ -13,6 +13,8 @@
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.control.Eval;
 
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.lazy;
 import io.vavr.Lazy;
 import io.vavr.collection.Iterator;
 import io.vavr.control.Option;
@@ -22,32 +24,23 @@
 /**
  * Simulates Higher Kinded Types for Lazy's
  * 
- * LazyKind is a Lazy and a Higher Kinded Type (LazyKind.µ,T)
+ * LazyKind is a Lazy and a Higher Kinded Type (lazy,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the Lazy
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final  class LazyKind<T> implements Higher<LazyKind.µ, T> {
+public final  class LazyKind<T> implements Higher<lazy, T> {
     
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
-
     /**
      * Convert the raw Higher Kinded Type for MaybeType types into the MaybeType type definition class
      * 
      * @param future HKT encoded list into a OptionalType
      * @return MaybeType
      */
-    public static <T> LazyKind<T> narrowK(final Higher<LazyKind.µ, T> future) {
+    public static <T> LazyKind<T> narrowK(final Higher<lazy, T> future) {
        return (LazyKind<T>)future;
     }
     /**
@@ -95,12 +88,12 @@ public static <T> LazyKind<T> widen(final Eval<T> eval) {
      * @param eval Type Constructor to convert back into narrowed type
      * @return LazyX from Higher Kinded Type
      */
-    public static <T> Lazy<T> narrow(final Higher<LazyKind.µ, T> eval) {
+    public static <T> Lazy<T> narrow(final Higher<lazy, T> eval) {
        
             return ((LazyKind) eval).boxed;
        
     }
-    public static <T> Eval<T> narrowEval(final Higher<LazyKind.µ, T> eval) {
+    public static <T> Eval<T> narrowEval(final Higher<lazy, T> eval) {
         
         return ToCyclopsReact.eval(((LazyKind) eval).boxed);
    
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
index 418c46af..e4e1e2ca 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
@@ -1,6 +1,8 @@
 package com.aol.cyclops.vavr.hkt;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.list;
 import cyclops.stream.ReactiveSeq;
 import io.vavr.collection.List;
 import org.reactivestreams.Publisher;
@@ -23,16 +25,7 @@
  */
 
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final class ListKind<T> implements Higher<ListKind.µ, T>, Publisher<T>, List<T> {
-
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+public final class ListKind<T> implements Higher<list, T>, Publisher<T>, List<T> {
 
     /**
      * Construct a HKT encoded completed List
@@ -76,10 +69,10 @@ public static <T> ListKind<T> widen(final List<T> completableList) {
      * @param flux HTK encoded type containing  a List to widen
      * @return HKT encoded type with a widened List
      */
-    public static <C2, T> Higher<C2, Higher<ListKind.µ, T>> widen2(Higher<C2, ListKind<T>> flux) {
+    public static <C2, T> Higher<C2, Higher<list, T>> widen2(Higher<C2, ListKind<T>> flux) {
         // a functor could be used (if C2 is a functor / one exists for C2 type)
         // instead of casting
-        // cast seems safer as Higher<ListKind.µ,T> must be a ListKind
+        // cast seems safer as Higher<list,T> must be a ListKind
         return (Higher) flux;
     }
 
@@ -95,7 +88,7 @@ public static <T> ListKind<T> widen(final Publisher<T> completableList) {
      * @param future HKT encoded list into a ListKind
      * @return ListKind
      */
-    public static <T> ListKind<T> narrowK(final Higher<ListKind.µ, T> future) {
+    public static <T> ListKind<T> narrowK(final Higher<list, T> future) {
         return (ListKind<T>) future;
     }
 
@@ -105,7 +98,7 @@ public static <T> ListKind<T> narrowK(final Higher<ListKind.µ, T> future) {
      * @param list Type Constructor to convert back into narrowed type
      * @return List from Higher Kinded Type
      */
-    public static <T> List<T> narrow(final Higher<ListKind.µ, T> list) {
+    public static <T> List<T> narrow(final Higher<list, T> list) {
 
         return ((ListKind<T>) list).narrow();
 
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
index e4c29abb..b2328fab 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
@@ -9,6 +9,10 @@
 import cyclops.companion.Optionals.OptionalKind;
 import cyclops.control.Eval;
 
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.option;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.optional;
 import io.vavr.collection.Iterator;
 import io.vavr.control.Option;
 import lombok.AccessLevel;
@@ -24,7 +28,7 @@
  * @param <T> Data type stored within the Option
  */
 
-public interface OptionKind<T> extends Higher<OptionKind.µ, T>, Option<T> {
+public interface OptionKind<T> extends Higher<option, T>, Option<T> {
     /**
      * Witness type
      * 
@@ -75,7 +79,7 @@ static <T> OptionKind<T> fromIterable(final Iterable<T> iterable) {
      * @param optional Optional to construct Option from
      * @return Option created from Optional
      */
-    public static <T> OptionKind<T> ofOptional(Higher<OptionalKind.µ,T> optional){
+    public static <T> OptionKind<T> ofOptional(Higher<optional,T> optional){
         return widen(Option.ofOptional(OptionalKind.narrowK(optional)));
     }
     public static <T> OptionKind<T> ofOptional(Optional<T> optional){
@@ -95,9 +99,9 @@ public static <T> OptionKind<T> widen(final Optional<T> optional) {
         
         return new Box<>(Option.ofOptional(optional));
     }
-    public static <C2,T> Higher<C2, Higher<OptionKind.µ,T>> widen2(Higher<C2, OptionKind<T>> nestedOption){
+    public static <C2,T> Higher<C2, Higher<option,T>> widen2(Higher<C2, OptionKind<T>> nestedOption){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<OptionKind.µ,T> must be a StreamKind
+        //cast seems safer as Higher<option,T> must be a StreamKind
         return (Higher)nestedOption;
     }
     /**
@@ -106,7 +110,7 @@ public static <T> OptionKind<T> widen(final Optional<T> optional) {
      * @param Optional Type Constructor to convert back into narrowed type
      * @return Optional from Higher Kinded Type
      */
-    public static <T> Optional<T> narrowOptional(final Higher<OptionKind.µ, T> Optional) {
+    public static <T> Optional<T> narrowOptional(final Higher<option, T> Optional) {
         
          return ((Box<T>)Optional).narrow().toJavaOptional();
         
@@ -117,7 +121,7 @@ public static <T> Optional<T> narrowOptional(final Higher<OptionKind.µ, T> Opti
      * @param future HKT encoded list into a OptionKind
      * @return OptionKind
      */
-    public static <T> OptionKind<T> narrowK(final Higher<OptionKind.µ, T> future) {
+    public static <T> OptionKind<T> narrowK(final Higher<option, T> future) {
        return (OptionKind<T>)future;
     }
     /**
@@ -181,7 +185,7 @@ public static <T> OptionKind<T> widen(final Option<T> maybe) {
      * @param maybe Type Constructor to convert back into narrowed type
      * @return OptionX from Higher Kinded Type
      */
-    public static <T> Option<T> narrow(final Higher<OptionKind.µ, T> maybe) {
+    public static <T> Option<T> narrow(final Higher<option, T> maybe) {
         if (maybe instanceof Option)
             return (Option) maybe;
         //this code should be unreachable due to HKT type checker
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
index ca3ead23..b7e92f95 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
@@ -19,6 +19,8 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.queue;
 import io.vavr.collection.LinearSeq;
 import io.vavr.collection.Queue;
 import lombok.AccessLevel;
@@ -28,22 +30,15 @@
 /**
  * Simulates Higher Kinded Types for Queue's
  * 
- * QueueKind is a Queue and a Higher Kinded Type (QueueKind.µ,T)
+ * QueueKind is a Queue and a Higher Kinded Type (queue,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the Queue
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public  class QueueKind<T> implements Higher<QueueKind.µ, T> {
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+public  class QueueKind<T> implements Higher<queue, T> {
+
 
     public static <T> QueueKind<T> of(T element) {
         return  widen(Queue.of(element));
@@ -74,9 +69,9 @@ public static <T> QueueKind<T> widen(final Queue<T> list) {
      * @param list HTK encoded type containing  a Queue to widen
      * @return HKT encoded type with a widened Queue
      */
-    public static <C2,T> Higher<C2, Higher<QueueKind.µ,T>> widen2(Higher<C2, QueueKind<T>> list){
+    public static <C2,T> Higher<C2, Higher<queue,T>> widen2(Higher<C2, QueueKind<T>> list){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<QueueKind.µ,T> must be a QueueKind
+        //cast seems safer as Higher<queue,T> must be a QueueKind
         return (Higher)list;
     }
     /**
@@ -85,7 +80,7 @@ public static <T> QueueKind<T> widen(final Queue<T> list) {
      * @param list HKT encoded list into a QueueKind
      * @return QueueKind
      */
-    public static <T> QueueKind<T> narrowK(final Higher<QueueKind.µ, T> list) {
+    public static <T> QueueKind<T> narrowK(final Higher<queue, T> list) {
        return (QueueKind<T>)list;
     }
     /**
@@ -94,7 +89,7 @@ public static <T> QueueKind<T> narrowK(final Higher<QueueKind.µ, T> list) {
      * @param list Type Constructor to convert back into narrowed type
      * @return QueueX from Higher Kinded Type
      */
-    public static <T> Queue<T> narrow(final Higher<QueueKind.µ, T> list) {
+    public static <T> Queue<T> narrow(final Higher<queue, T> list) {
         return ((QueueKind)list).narrow();
        
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
index 6b9813d6..7a98704c 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
@@ -1,6 +1,8 @@
 package com.aol.cyclops.vavr.hkt;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.stream;
 import cyclops.stream.ReactiveSeq;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
@@ -21,16 +23,7 @@
  */
 
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final class StreamKind<T> implements Higher<StreamKind.µ, T>, Publisher<T>, Stream<T>{
-
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+public final class StreamKind<T> implements Higher<stream, T>, Publisher<T>, Stream<T>{
 
     /**
      * Construct a HKT encoded completed Stream
@@ -73,10 +66,10 @@ public static <T> StreamKind<T> widen(final Stream<T> stream) {
      * @param flux HTK encoded type containing  a Stream to widen
      * @return HKT encoded type with a widened Stream
      */
-    public static <C2, T> Higher<C2, Higher<StreamKind.µ, T>> widen2(Higher<C2, StreamKind<T>> flux) {
+    public static <C2, T> Higher<C2, Higher<stream, T>> widen2(Higher<C2, StreamKind<T>> flux) {
         // a functor could be used (if C2 is a functor / one exists for C2 type)
         // instead of casting
-        // cast seems safer as Higher<StreamKind.µ,T> must be a StreamKind
+        // cast seems safer as Higher<stream,T> must be a StreamKind
         return (Higher) flux;
     }
 
@@ -92,7 +85,7 @@ public static <T> StreamKind<T> widen(final Publisher<T> completableStream) {
      * @param future HKT encoded list into a StreamKind
      * @return StreamKind
      */
-    public static <T> StreamKind<T> narrowK(final Higher<StreamKind.µ, T> future) {
+    public static <T> StreamKind<T> narrowK(final Higher<stream, T> future) {
         return (StreamKind<T>) future;
     }
 
@@ -102,7 +95,7 @@ public static <T> StreamKind<T> narrowK(final Higher<StreamKind.µ, T> future) {
      * @param stream Type Constructor to convert back into narrowed type
      * @return Stream from Higher Kinded Type
      */
-    public static <T> Stream<T> narrow(final Higher<StreamKind.µ, T> stream) {
+    public static <T> Stream<T> narrow(final Higher<stream, T> stream) {
 
         return ((StreamKind<T>) stream).narrow();
 
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
index 5f1c0395..e4cd3df0 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
@@ -19,6 +19,8 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.vector;
 import io.vavr.collection.Vector;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -27,22 +29,14 @@
 /**
  * Simulates Higher Kinded Types for Vector's
  * 
- * VectorKind is a Vector and a Higher Kinded Type (VectorKind.µ,T)
+ * VectorKind is a Vector and a Higher Kinded Type (vector,T)
  * 
  * @author johnmcclean
  *
  * @param <T> Data type stored within the Vector
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public  class VectorKind<T> implements Higher<VectorKind.µ, T>{
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
-    }
+public  class VectorKind<T> implements Higher<vector, T>{
 
     public static <T> VectorKind<T> of(T element) {
         return  widen(Vector.of(element));
@@ -73,9 +67,9 @@ public static <T> VectorKind<T> widen(final Vector<T> list) {
      * @param list HTK encoded type containing  a Vector to widen
      * @return HKT encoded type with a widened Vector
      */
-    public static <C2,T> Higher<C2, Higher<VectorKind.µ,T>> widen2(Higher<C2, VectorKind<T>> list){
+    public static <C2,T> Higher<C2, Higher<vector,T>> widen2(Higher<C2, VectorKind<T>> list){
         //a functor could be used (if C2 is a functor / one exists for C2 type) instead of casting
-        //cast seems safer as Higher<VectorKind.µ,T> must be a VectorKind
+        //cast seems safer as Higher<vector,T> must be a VectorKind
         return (Higher)list;
     }
     /**
@@ -84,7 +78,7 @@ public static <T> VectorKind<T> widen(final Vector<T> list) {
      * @param list HKT encoded list into a VectorKind
      * @return VectorKind
      */
-    public static <T> VectorKind<T> narrowK(final Higher<VectorKind.µ, T> list) {
+    public static <T> VectorKind<T> narrowK(final Higher<vector, T> list) {
        return (VectorKind<T>)list;
     }
     /**
@@ -93,7 +87,7 @@ public static <T> VectorKind<T> narrowK(final Higher<VectorKind.µ, T> list) {
      * @param list Type Constructor to convert back into narrowed type
      * @return VectorX from Higher Kinded Type
      */
-    public static <T> Vector<T> narrow(final Higher<VectorKind.µ, T> list) {
+    public static <T> Vector<T> narrow(final Higher<vector, T> list) {
         return ((VectorKind)list).narrow();
        
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
index 63ccc3ff..883f145f 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
@@ -338,7 +338,7 @@ public static class Instances {
          *
          * @return A functor for Arrays
          */
-        public static <T,R>Functor<ArrayKind.µ> functor(){
+        public static <T,R>Functor<array> functor(){
             BiFunction<ArrayKind<T>,Function<? super T, ? extends R>,ArrayKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -357,8 +357,8 @@ public static class Instances {
          *
          * @return A factory for Arrays
          */
-        public static <T> Pure<ArrayKind.µ> unit(){
-            return General.<ArrayKind.µ,T>unit(ArrayKind::of);
+        public static <T> Pure<array> unit(){
+            return General.<array,T>unit(ArrayKind::of);
         }
         /**
          *
@@ -397,7 +397,7 @@ public static class Instances {
          *
          * @return A zipper for Arrays
          */
-        public static <T,R> Applicative<ArrayKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<array> zippingApplicative(){
             BiFunction<ArrayKind< Function<T, R>>,ArrayKind<T>,ArrayKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -427,9 +427,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Arrays
          */
-        public static <T,R> Monad<ArrayKind.µ> monad(){
+        public static <T,R> Monad<array> monad(){
 
-            BiFunction<Higher<ArrayKind.µ,T>,Function<? super T, ? extends Higher<ArrayKind.µ,R>>,Higher<ArrayKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<array,T>,Function<? super T, ? extends Higher<array,R>>,Higher<array,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -449,7 +449,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<ArrayKind.µ> monadZero(){
+        public static <T,R> MonadZero<array> monadZero(){
 
             return General.monadZero(monad(), ArrayKind.widen(Array.empty()));
         }
@@ -465,9 +465,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Arrays by concatenation
          */
-        public static <T> MonadPlus<ArrayKind.µ> monadPlus(){
+        public static <T> MonadPlus<array> monadPlus(){
             Monoid<ArrayKind<T>> m = Monoid.of(ArrayKind.widen(Array.empty()), Instances::concat);
-            Monoid<Higher<ArrayKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<array,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -486,15 +486,15 @@ public static class Instances {
          * @param m Monoid to use for combining Arrays
          * @return Type class for combining Arrays
          */
-        public static <T> MonadPlus<ArrayKind.µ> monadPlus(Monoid<ArrayKind<T>> m){
-            Monoid<Higher<ArrayKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<array> monadPlus(Monoid<ArrayKind<T>> m){
+            Monoid<Higher<array,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<ArrayKind.µ> traverse(){
+        public static <C2,T> Traverse<array> traverse(){
 
             BiFunction<Applicative<C2>,ArrayKind<Higher<C2, T>>,Higher<C2, ArrayKind<T>>> sequenceFn = (ap, list) -> {
 
@@ -512,7 +512,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<ArrayKind.µ,Higher<C2, T>>,Higher<C2, Higher<ArrayKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<array,Higher<C2, T>>,Higher<C2, Higher<array,T>>> sequenceNarrow  =
                     (a,b) -> ArrayKind.widen2(sequenceFn.apply(a, ArrayKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -532,9 +532,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<ArrayKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<ArrayKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(ArrayKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<ArrayKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(ArrayKind.narrow(l)).reduce(m);
+        public static <T> Foldable<array> foldable(){
+            BiFunction<Monoid<T>,Higher<array,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(ArrayKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<array,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(ArrayKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -547,7 +547,7 @@ private static  <T> ArrayKind<T> concat(ArrayKind<T> l1, ArrayKind<T> l2){
         private static <T,R> ArrayKind<R> ap(ArrayKind<Function< T, R>> lt, ArrayKind<T> list){
             return ArrayKind.widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toArray());
         }
-        private static <T,R> Higher<ArrayKind.µ,R> flatMap(Higher<ArrayKind.µ,T> lt, Function<? super T, ? extends  Higher<ArrayKind.µ,R>> fn){
+        private static <T,R> Higher<array,R> flatMap(Higher<array,T> lt, Function<? super T, ? extends  Higher<array,R>> fn){
             return ArrayKind.widen(ArrayKind.narrow(lt).flatMap(fn.andThen(ArrayKind::narrow)));
         }
         private static <T,R> ArrayKind<R> map(ArrayKind<T> lt, Function<? super T, ? extends R> fn){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
index 5487d088..074e9cd3 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
@@ -731,7 +731,7 @@ public static class Instances {
          *
          * @return A functor for Futures
          */
-        public static <T,R>Functor<FutureKind.µ> functor(){
+        public static <T,R>Functor<future> functor(){
             BiFunction<FutureKind<T>,Function<? super T, ? extends R>,FutureKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -750,8 +750,8 @@ public static class Instances {
          *
          * @return A factory for Futures
          */
-        public static <T> Pure<FutureKind.µ> unit(){
-            return General.<FutureKind.µ,T>unit(Instances::of);
+        public static <T> Pure<future> unit(){
+            return General.<future,T>unit(Instances::of);
         }
         /**
          *
@@ -789,7 +789,7 @@ public static class Instances {
          *
          * @return A zipper for Futures
          */
-        public static <T,R> Applicative<FutureKind.µ> applicative(){
+        public static <T,R> Applicative<future> applicative(){
             BiFunction<FutureKind< Function<T, R>>,FutureKind<T>,FutureKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -819,9 +819,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Futures
          */
-        public static <T,R> Monad<FutureKind.µ> monad(){
+        public static <T,R> Monad<future> monad(){
 
-            BiFunction<Higher<FutureKind.µ,T>,Function<? super T, ? extends Higher<FutureKind.µ,R>>,Higher<FutureKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<future,T>,Function<? super T, ? extends Higher<future,R>>,Higher<future,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -841,7 +841,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<FutureKind.µ> monadZero(){
+        public static <T,R> MonadZero<future> monadZero(){
 
             return General.monadZero(monad(), FutureKind.promise());
         }
@@ -857,12 +857,12 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Futures by concatenation
          */
-        public static <T> MonadPlus<FutureKind.µ> monadPlus(){
+        public static <T> MonadPlus<future> monadPlus(){
             Monoid<cyclops.async.Future<T>> mn = Monoids.firstSuccessfulFuture();
             Monoid<FutureKind<T>> m = Monoid.of(FutureKind.widen(mn.zero()), (f, g)-> FutureKind.widen(
                     mn.apply(ToCyclopsReact.future(f), ToCyclopsReact.future(g))));
 
-            Monoid<Higher<FutureKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<future,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -881,15 +881,15 @@ public static class Instances {
          * @param m Monoid to use for combining Futures
          * @return Type class for combining Futures
          */
-        public static <T> MonadPlus<FutureKind.µ> monadPlus(Monoid<FutureKind<T>> m){
-            Monoid<Higher<FutureKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<future> monadPlus(Monoid<FutureKind<T>> m){
+            Monoid<Higher<future,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<FutureKind.µ> traverse(){
+        public static <C2,T> Traverse<future> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -909,13 +909,13 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<FutureKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<FutureKind.µ,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), FutureKind.narrow(l).get());
-            BiFunction<Monoid<T>,Higher<FutureKind.µ,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), FutureKind.narrow(l).get());
+        public static <T> Foldable<future> foldable(){
+            BiFunction<Monoid<T>,Higher<future,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), FutureKind.narrow(l).get());
+            BiFunction<Monoid<T>,Higher<future,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), FutureKind.narrow(l).get());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<FutureKind.µ> comonad(){
-            Function<? super Higher<FutureKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(FutureKind::narrow).get();
+        public static <T> Comonad<future> comonad(){
+            Function<? super Higher<future, T>, ? extends T> extractFn = maybe -> maybe.convert(FutureKind::narrow).get();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -926,7 +926,7 @@ private static <T,R> FutureKind<R> ap(FutureKind<Function< T, R>> lt, FutureKind
             return FutureKind.widen(ToCyclopsReact.future(lt).combine(ToCyclopsReact.future(list), (a, b)->a.apply(b)));
 
         }
-        private static <T,R> Higher<FutureKind.µ,R> flatMap(Higher<FutureKind.µ,T> lt, Function<? super T, ? extends  Higher<FutureKind.µ,R>> fn){
+        private static <T,R> Higher<future,R> flatMap(Higher<future,T> lt, Function<? super T, ? extends  Higher<future,R>> fn){
             return FutureKind.widen(FutureKind.narrow(lt).flatMap(fn.andThen(FutureKind::narrowK)));
         }
         private static <T,R> FutureKind<R> map(FutureKind<T> lt, Function<? super T, ? extends R> fn){
@@ -934,8 +934,8 @@ private static <T,R> FutureKind<R> map(FutureKind<T> lt, Function<? super T, ? e
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<FutureKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                              Higher<FutureKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<future, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                              Higher<future, T> ds){
             Future<T> future = FutureKind.narrow(ds);
             return applicative.map(FutureKind::successful, fn.apply(future.get()));
         }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
index 83875cbf..2b2ff195 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
@@ -14,6 +14,8 @@
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.lazy;
 import cyclops.monads.Witness;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.EvalT;
@@ -457,7 +459,7 @@ public static class Instances {
          *
          * @return A functor for Lazys
          */
-        public static <T,R>Functor<LazyKind.µ> functor(){
+        public static <T,R>Functor<lazy> functor(){
             BiFunction<LazyKind<T>,Function<? super T, ? extends R>,LazyKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -476,8 +478,8 @@ public static class Instances {
          *
          * @return A factory for Lazys
          */
-        public static <T> Pure<LazyKind.µ> unit(){
-            return General.<LazyKind.µ,T>unit(Instances::of);
+        public static <T> Pure<lazy> unit(){
+            return General.<lazy,T>unit(Instances::of);
         }
         /**
          *
@@ -516,7 +518,7 @@ public static class Instances {
          *
          * @return A zipper for Lazys
          */
-        public static <T,R> Applicative<LazyKind.µ> applicative(){
+        public static <T,R> Applicative<lazy> applicative(){
             BiFunction<LazyKind< Function<T, R>>,LazyKind<T>,LazyKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -546,9 +548,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Lazys
          */
-        public static <T,R> Monad<LazyKind.µ> monad(){
+        public static <T,R> Monad<lazy> monad(){
 
-            BiFunction<Higher<LazyKind.µ,T>,Function<? super T, ? extends Higher<LazyKind.µ,R>>,Higher<LazyKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<lazy,T>,Function<? super T, ? extends Higher<lazy,R>>,Higher<lazy,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -568,7 +570,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<LazyKind.µ> monadZero(){
+        public static <T,R> MonadZero<lazy> monadZero(){
 
             return General.monadZero(monad(), LazyKind.of(()->null));
         }
@@ -584,10 +586,10 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Lazys by concatenation
          */
-        public static <T> MonadPlus<LazyKind.µ> monadPlus(){
+        public static <T> MonadPlus<lazy> monadPlus(){
             Monoid<LazyKind<T>> m = Monoid.of( LazyKind.of(()->null),
                     (a,b)-> a.get()==null? b: a);
-            Monoid<Higher<LazyKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<lazy,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -606,15 +608,15 @@ public static class Instances {
          * @param m Monoid to use for combining Lazys
          * @return Type class for combining Lazys
          */
-        public static <T> MonadPlus<LazyKind.µ> monadPlus(Monoid<LazyKind<T>> m){
-            Monoid<Higher<LazyKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<lazy> monadPlus(Monoid<LazyKind<T>> m){
+            Monoid<Higher<lazy,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<LazyKind.µ> traverse(){
+        public static <C2,T> Traverse<lazy> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -634,13 +636,13 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<LazyKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<LazyKind.µ,T>,T> foldRightFn =  (m, l)-> LazyKind.narrow(l).getOrElse(m.zero());
-            BiFunction<Monoid<T>,Higher<LazyKind.µ,T>,T> foldLeftFn = (m, l)-> LazyKind.narrow(l).getOrElse(m.zero());
+        public static <T> Foldable<lazy> foldable(){
+            BiFunction<Monoid<T>,Higher<lazy,T>,T> foldRightFn =  (m, l)-> LazyKind.narrow(l).getOrElse(m.zero());
+            BiFunction<Monoid<T>,Higher<lazy,T>,T> foldLeftFn = (m, l)-> LazyKind.narrow(l).getOrElse(m.zero());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<LazyKind.µ> comonad(){
-            Function<? super Higher<LazyKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(LazyKind::narrow).get();
+        public static <T> Comonad<lazy> comonad(){
+            Function<? super Higher<lazy, T>, ? extends T> extractFn = maybe -> maybe.convert(LazyKind::narrow).get();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -651,7 +653,7 @@ private static <T,R> LazyKind<R> ap(LazyKind<Function< T, R>> lt, LazyKind<T> la
             return LazyKind.widen(FromCyclopsReact.lazy(ToCyclopsReact.eval(lt.narrow()).combine(ToCyclopsReact.eval(lazy.narrow()), (a, b)->a.apply(b))));
 
         }
-        private static <T,R> Higher<LazyKind.µ,R> flatMap(Higher<LazyKind.µ,T> lt, Function<? super T, ? extends  Higher<LazyKind.µ,R>> fn){
+        private static <T,R> Higher<lazy,R> flatMap(Higher<lazy,T> lt, Function<? super T, ? extends  Higher<lazy,R>> fn){
             return LazyKind.widen(LazyKind.narrowEval(lt).flatMap(fn.andThen(LazyKind::narrowEval)));
         }
         private static <T,R> LazyKind<R> map(LazyKind<T> lt, Function<? super T, ? extends R> fn){
@@ -659,8 +661,8 @@ private static <T,R> LazyKind<R> map(LazyKind<T> lt, Function<? super T, ? exten
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<LazyKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                            Higher<LazyKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<lazy, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                            Higher<lazy, T> ds){
 
             Lazy<T> eval = LazyKind.narrow(ds);
             Higher<C2, R> ds2 = fn.apply(eval.get());
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
index 41f7af7d..3692eb24 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
@@ -336,7 +336,7 @@ public static class Instances {
          *
          * @return A functor for Lists
          */
-        public static <T,R>Functor<ListKind.µ> functor(){
+        public static <T,R>Functor<list> functor(){
             BiFunction<ListKind<T>,Function<? super T, ? extends R>,ListKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -355,8 +355,8 @@ public static class Instances {
          *
          * @return A factory for Lists
          */
-        public static <T> Pure<ListKind.µ> unit(){
-            return General.<ListKind.µ,T>unit(Instances::of);
+        public static <T> Pure<list> unit(){
+            return General.<list,T>unit(Instances::of);
         }
         /**
          *
@@ -394,7 +394,7 @@ public static class Instances {
          *
          * @return A zipper for Lists
          */
-        public static <T,R> Applicative<ListKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<list> zippingApplicative(){
             BiFunction<ListKind< Function<T, R>>,ListKind<T>,ListKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -424,9 +424,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Lists
          */
-        public static <T,R> Monad<ListKind.µ> monad(){
+        public static <T,R> Monad<list> monad(){
 
-            BiFunction<Higher<ListKind.µ,T>,Function<? super T, ? extends Higher<ListKind.µ,R>>,Higher<ListKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<list,T>,Function<? super T, ? extends Higher<list,R>>,Higher<list,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -446,10 +446,10 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<ListKind.µ> monadZero(){
-            BiFunction<Higher<ListKind.µ,T>,Predicate<? super T>,Higher<ListKind.µ,T>> filter = Instances::filter;
-            Supplier<Higher<ListKind.µ, T>> zero = ()-> ListKind.widen(List.empty());
-            return General.<ListKind.µ,T,R>monadZero(monad(), zero,filter);
+        public static <T,R> MonadZero<list> monadZero(){
+            BiFunction<Higher<list,T>,Predicate<? super T>,Higher<list,T>> filter = Instances::filter;
+            Supplier<Higher<list, T>> zero = ()-> ListKind.widen(List.empty());
+            return General.<list,T,R>monadZero(monad(), zero,filter);
         }
         /**
          * <pre>
@@ -463,9 +463,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Lists by concatenation
          */
-        public static <T> MonadPlus<ListKind.µ> monadPlus(){
+        public static <T> MonadPlus<list> monadPlus(){
             Monoid<ListKind<T>> m = Monoid.of(ListKind.widen(List.<T>empty()), Instances::concat);
-            Monoid<Higher<ListKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -484,15 +484,15 @@ public static class Instances {
          * @param m Monoid to use for combining Lists
          * @return Type class for combining Lists
          */
-        public static <T> MonadPlus<ListKind.µ> monadPlus(Monoid<ListKind<T>> m){
-            Monoid<Higher<ListKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<list> monadPlus(Monoid<ListKind<T>> m){
+            Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<ListKind.µ> traverse(){
+        public static <C2,T> Traverse<list> traverse(){
             BiFunction<Applicative<C2>,ListKind<Higher<C2, T>>,Higher<C2, ListKind<T>>> sequenceFn = (ap, list) -> {
 
                 Higher<C2,ListKind<T>> identity = ap.unit(ListKind.widen(List.empty()));
@@ -507,7 +507,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<ListKind.µ,Higher<C2, T>>,Higher<C2, Higher<ListKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<list,Higher<C2, T>>,Higher<C2, Higher<list,T>>> sequenceNarrow  =
                     (a,b) -> ListKind.widen2(sequenceFn.apply(a, ListKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -527,9 +527,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<ListKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<ListKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(ListKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<ListKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(ListKind.narrow(l)).reduce(m);
+        public static <T> Foldable<list> foldable(){
+            BiFunction<Monoid<T>,Higher<list,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(ListKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<list,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(ListKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -542,13 +542,13 @@ private <T> ListKind<T> of(T value){
         private static <T,R> ListKind<R> ap(ListKind<Function< T, R>> lt, ListKind<T> list){
             return ListKind.widen(lt.toReactiveSeq().zip(list,(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<ListKind.µ,R> flatMap(Higher<ListKind.µ,T> lt, Function<? super T, ? extends  Higher<ListKind.µ,R>> fn){
+        private static <T,R> Higher<list,R> flatMap(Higher<list,T> lt, Function<? super T, ? extends  Higher<list,R>> fn){
             return ListKind.widen(ListKind.narrowK(lt).flatMap(fn.andThen(ListKind::narrowK)));
         }
         private static <T,R> ListKind<R> map(ListKind<T> lt, Function<? super T, ? extends R> fn){
             return ListKind.widen(lt.map(fn));
         }
-        private static <T> ListKind<T> filter(Higher<ListKind.µ,T> lt, Predicate<? super T> fn){
+        private static <T> ListKind<T> filter(Higher<list,T> lt, Predicate<? super T> fn){
             return ListKind.widen(ListKind.narrow(lt).filter(fn));
         }
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
index 5e568140..13cb28d6 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
@@ -615,7 +615,7 @@ public static class Instances {
          *
          * @return A functor for Options
          */
-        public static <T,R>Functor<OptionKind.µ> functor(){
+        public static <T,R>Functor<option> functor(){
             BiFunction<OptionKind<T>,Function<? super T, ? extends R>,OptionKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -634,8 +634,8 @@ public static class Instances {
          *
          * @return A factory for Options
          */
-        public static <T> Pure<OptionKind.µ> unit(){
-            return General.<OptionKind.µ,T>unit(Instances::of);
+        public static <T> Pure<option> unit(){
+            return General.<option,T>unit(Instances::of);
         }
         /**
          *
@@ -674,7 +674,7 @@ public static class Instances {
          *
          * @return A zipper for Options
          */
-        public static <T,R> Applicative<OptionKind.µ> applicative(){
+        public static <T,R> Applicative<option> applicative(){
             BiFunction<OptionKind< Function<T, R>>,OptionKind<T>,OptionKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -704,9 +704,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Options
          */
-        public static <T,R> Monad<OptionKind.µ> monad(){
+        public static <T,R> Monad<option> monad(){
 
-            BiFunction<Higher<OptionKind.µ,T>,Function<? super T, ? extends Higher<OptionKind.µ,R>>,Higher<OptionKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<option,T>,Function<? super T, ? extends Higher<option,R>>,Higher<option,R>> flatMap = Instances::flatMap;
             return General.monad(applicative(), flatMap);
         }
         /**
@@ -726,7 +726,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<OptionKind.µ> monadZero(){
+        public static <T,R> MonadZero<option> monadZero(){
 
             return General.monadZero(monad(), OptionKind.none());
         }
@@ -742,10 +742,10 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Options by concatenation
          */
-        public static <T> MonadPlus<OptionKind.µ> monadPlus(){
+        public static <T> MonadPlus<option> monadPlus(){
             Monoid<OptionKind<T>> m = Monoid.of( OptionKind.ofOptional(Monoids.<T>firstPresentOptional().zero()),
                     (a,b)-> OptionKind.ofOptional(Monoids.<T>firstPresentOptional().apply(a.toJavaOptional(),b.toJavaOptional())));
-            Monoid<Higher<OptionKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<option,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -764,15 +764,15 @@ public static class Instances {
          * @param m Monoid to use for combining Options
          * @return Type class for combining Options
          */
-        public static <T> MonadPlus<OptionKind.µ> monadPlus(Monoid<OptionKind<T>> m){
-            Monoid<Higher<OptionKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<option> monadPlus(Monoid<OptionKind<T>> m){
+            Monoid<Higher<option,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<OptionKind.µ> traverse(){
+        public static <C2,T> Traverse<option> traverse(){
 
             return General.traverseByTraverse(applicative(), Instances::traverseA);
         }
@@ -792,13 +792,13 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<OptionKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<OptionKind.µ,T>,T> foldRightFn =  (m, l)-> OptionKind.narrow(l).getOrElse(m.zero());
-            BiFunction<Monoid<T>,Higher<OptionKind.µ,T>,T> foldLeftFn = (m, l)-> OptionKind.narrow(l).getOrElse(m.zero());
+        public static <T> Foldable<option> foldable(){
+            BiFunction<Monoid<T>,Higher<option,T>,T> foldRightFn =  (m, l)-> OptionKind.narrow(l).getOrElse(m.zero());
+            BiFunction<Monoid<T>,Higher<option,T>,T> foldLeftFn = (m, l)-> OptionKind.narrow(l).getOrElse(m.zero());
             return General.foldable(foldRightFn, foldLeftFn);
         }
-        public static <T> Comonad<OptionKind.µ> comonad(){
-            Function<? super Higher<OptionKind.µ, T>, ? extends T> extractFn = maybe -> maybe.convert(OptionKind::narrow).get();
+        public static <T> Comonad<option> comonad(){
+            Function<? super Higher<option, T>, ? extends T> extractFn = maybe -> maybe.convert(OptionKind::narrow).get();
             return General.comonad(functor(), unit(), extractFn);
         }
 
@@ -809,7 +809,7 @@ private static <T,R> OptionKind<R> ap(OptionKind<Function< T, R>> lt, OptionKind
             return OptionKind.widen(FromCyclopsReact.option(ToCyclopsReact.maybe(lt).combine(ToCyclopsReact.maybe(option), (a, b)->a.apply(b))));
 
         }
-        private static <T,R> Higher<OptionKind.µ,R> flatMap(Higher<OptionKind.µ,T> lt, Function<? super T, ? extends  Higher<OptionKind.µ,R>> fn){
+        private static <T,R> Higher<option,R> flatMap(Higher<option,T> lt, Function<? super T, ? extends  Higher<option,R>> fn){
             return OptionKind.widen(OptionKind.narrow(lt).flatMap(fn.andThen(OptionKind::narrow)));
         }
         private static <T,R> OptionKind<R> map(OptionKind<T> lt, Function<? super T, ? extends R> fn){
@@ -817,8 +817,8 @@ private static <T,R> OptionKind<R> map(OptionKind<T> lt, Function<? super T, ? e
         }
 
 
-        private static <C2,T,R> Higher<C2, Higher<OptionKind.µ, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
-                                                                              Higher<OptionKind.µ, T> ds){
+        private static <C2,T,R> Higher<C2, Higher<option, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                              Higher<option, T> ds){
 
             Option<T> option = OptionKind.narrow(ds);
             Higher<C2, OptionKind<R>> res = ToCyclopsReact.maybe(option).visit(some-> applicative.map(m-> OptionKind.of(m), fn.apply(some)),
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
index c3326972..bf65758c 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
@@ -336,7 +336,7 @@ public static class Instances {
          *
          * @return A functor for Queues
          */
-        public static <T,R>Functor<QueueKind.µ> functor(){
+        public static <T,R>Functor<queue> functor(){
             BiFunction<QueueKind<T>,Function<? super T, ? extends R>,QueueKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -355,8 +355,8 @@ public static class Instances {
          *
          * @return A factory for Queues
          */
-        public static <T> Pure<QueueKind.µ> unit(){
-            return General.<QueueKind.µ,T>unit(QueueKind::of);
+        public static <T> Pure<queue> unit(){
+            return General.<queue,T>unit(QueueKind::of);
         }
         /**
          *
@@ -395,7 +395,7 @@ public static class Instances {
          *
          * @return A zipper for Queues
          */
-        public static <T,R> Applicative<QueueKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<queue> zippingApplicative(){
             BiFunction<QueueKind< Function<T, R>>,QueueKind<T>,QueueKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -425,9 +425,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Queues
          */
-        public static <T,R> Monad<QueueKind.µ> monad(){
+        public static <T,R> Monad<queue> monad(){
 
-            BiFunction<Higher<QueueKind.µ,T>,Function<? super T, ? extends Higher<QueueKind.µ,R>>,Higher<QueueKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<queue,T>,Function<? super T, ? extends Higher<queue,R>>,Higher<queue,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -447,7 +447,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<QueueKind.µ> monadZero(){
+        public static <T,R> MonadZero<queue> monadZero(){
 
             return General.monadZero(monad(), QueueKind.widen(Queue.empty()));
         }
@@ -463,9 +463,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Queues by concatenation
          */
-        public static <T> MonadPlus<QueueKind.µ> monadPlus(){
+        public static <T> MonadPlus<queue> monadPlus(){
             Monoid<QueueKind<T>> m = Monoid.of(QueueKind.widen(Queue.empty()), Instances::concat);
-            Monoid<Higher<QueueKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<queue,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -484,15 +484,15 @@ public static class Instances {
          * @param m Monoid to use for combining Queues
          * @return Type class for combining Queues
          */
-        public static <T> MonadPlus<QueueKind.µ> monadPlus(Monoid<QueueKind<T>> m){
-            Monoid<Higher<QueueKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<queue> monadPlus(Monoid<QueueKind<T>> m){
+            Monoid<Higher<queue,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<QueueKind.µ> traverse(){
+        public static <C2,T> Traverse<queue> traverse(){
 
             BiFunction<Applicative<C2>,QueueKind<Higher<C2, T>>,Higher<C2, QueueKind<T>>> sequenceFn = (ap, list) -> {
 
@@ -510,7 +510,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<QueueKind.µ,Higher<C2, T>>,Higher<C2, Higher<QueueKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<queue,Higher<C2, T>>,Higher<C2, Higher<queue,T>>> sequenceNarrow  =
                     (a,b) -> QueueKind.widen2(sequenceFn.apply(a, QueueKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -530,9 +530,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<QueueKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<QueueKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(QueueKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<QueueKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(QueueKind.narrow(l)).reduce(m);
+        public static <T> Foldable<queue> foldable(){
+            BiFunction<Monoid<T>,Higher<queue,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(QueueKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<queue,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(QueueKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -545,7 +545,7 @@ private static  <T> QueueKind<T> concat(QueueKind<T> l1, QueueKind<T> l2){
         private static <T,R> QueueKind<R> ap(QueueKind<Function< T, R>> lt, QueueKind<T> list){
             return QueueKind.widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toQueue());
         }
-        private static <T,R> Higher<QueueKind.µ,R> flatMap(Higher<QueueKind.µ,T> lt, Function<? super T, ? extends  Higher<QueueKind.µ,R>> fn){
+        private static <T,R> Higher<queue,R> flatMap(Higher<queue,T> lt, Function<? super T, ? extends  Higher<queue,R>> fn){
             return QueueKind.widen(QueueKind.narrow(lt).flatMap(fn.andThen(QueueKind::narrow)));
         }
         private static <T,R> QueueKind<R> map(QueueKind<T> lt, Function<? super T, ? extends R> fn){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index add60c53..9393d219 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -336,7 +336,7 @@ public static class Instances {
          *
          * @return A functor for Streams
          */
-        public static <T,R>Functor<StreamKind.µ> functor(){
+        public static <T,R>Functor<stream> functor(){
             BiFunction<StreamKind<T>,Function<? super T, ? extends R>,StreamKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -355,8 +355,8 @@ public static class Instances {
          *
          * @return A factory for Streams
          */
-        public static <T> Pure<StreamKind.µ> unit(){
-            return General.<StreamKind.µ,T>unit(StreamKind::just);
+        public static <T> Pure<stream> unit(){
+            return General.<stream,T>unit(StreamKind::just);
         }
         /**
          *
@@ -395,7 +395,7 @@ public static class Instances {
          *
          * @return A zipper for Streams
          */
-        public static <T,R> Applicative<StreamKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<stream> zippingApplicative(){
             BiFunction<StreamKind< Function<T, R>>,StreamKind<T>,StreamKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -425,9 +425,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Streams
          */
-        public static <T,R> Monad<StreamKind.µ> monad(){
+        public static <T,R> Monad<stream> monad(){
 
-            BiFunction<Higher<StreamKind.µ,T>,Function<? super T, ? extends Higher<StreamKind.µ,R>>,Higher<StreamKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<stream,T>,Function<? super T, ? extends Higher<stream,R>>,Higher<stream,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -447,7 +447,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<StreamKind.µ> monadZero(){
+        public static <T,R> MonadZero<stream> monadZero(){
 
             return General.monadZero(monad(), StreamKind.widen(Stream.empty()));
         }
@@ -463,9 +463,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Streams by concatenation
          */
-        public static <T> MonadPlus<StreamKind.µ> monadPlus(){
+        public static <T> MonadPlus<stream> monadPlus(){
             Monoid<StreamKind<T>> m = Monoid.of(StreamKind.widen(Stream.empty()), Instances::concat);
-            Monoid<Higher<StreamKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<stream,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -484,15 +484,15 @@ public static class Instances {
          * @param m Monoid to use for combining Streams
          * @return Type class for combining Streams
          */
-        public static <T> MonadPlus<StreamKind.µ> monadPlus(Monoid<StreamKind<T>> m){
-            Monoid<Higher<StreamKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<stream> monadPlus(Monoid<StreamKind<T>> m){
+            Monoid<Higher<stream,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<StreamKind.µ> traverse(){
+        public static <C2,T> Traverse<stream> traverse(){
 
             BiFunction<Applicative<C2>,StreamKind<Higher<C2, T>>,Higher<C2, StreamKind<T>>> sequenceFn = (ap, list) -> {
 
@@ -510,7 +510,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<StreamKind.µ,Higher<C2, T>>,Higher<C2, Higher<StreamKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<stream,Higher<C2, T>>,Higher<C2, Higher<stream,T>>> sequenceNarrow  =
                     (a,b) -> StreamKind.widen2(sequenceFn.apply(a, StreamKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -530,9 +530,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<StreamKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<StreamKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<StreamKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).reduce(m);
+        public static <T> Foldable<stream> foldable(){
+            BiFunction<Monoid<T>,Higher<stream,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<stream,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(StreamKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -545,7 +545,7 @@ private static  <T> StreamKind<T> concat(StreamKind<T> l1, StreamKind<T> l2){
         private static <T,R> StreamKind<R> ap(StreamKind<Function< T, R>> lt, StreamKind<T> list){
             return StreamKind.widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt).zip(list, (a, b)->a.apply(b))).toStream());
         }
-        private static <T,R> Higher<StreamKind.µ,R> flatMap(Higher<StreamKind.µ,T> lt, Function<? super T, ? extends  Higher<StreamKind.µ,R>> fn){
+        private static <T,R> Higher<stream,R> flatMap(Higher<stream,T> lt, Function<? super T, ? extends  Higher<stream,R>> fn){
             return StreamKind.widen(StreamKind.narrow(lt).flatMap(fn.andThen(StreamKind::narrow)));
         }
         private static <T,R> StreamKind<R> map(StreamKind<T> lt, Function<? super T, ? extends R> fn){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java
index ac6a535c..64cdb465 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java
@@ -339,7 +339,7 @@ public static class Instances {
          *
          * @return A functor for Vectors
          */
-        public static <T,R>Functor<VectorKind.µ> functor(){
+        public static <T,R>Functor<vector> functor(){
             BiFunction<VectorKind<T>,Function<? super T, ? extends R>,VectorKind<R>> map = Instances::map;
             return General.functor(map);
         }
@@ -358,8 +358,8 @@ public static class Instances {
          *
          * @return A factory for Vectors
          */
-        public static <T> Pure<VectorKind.µ> unit(){
-            return General.<VectorKind.µ,T>unit(VectorKind::of);
+        public static <T> Pure<vector> unit(){
+            return General.<vector,T>unit(VectorKind::of);
         }
         /**
          *
@@ -398,7 +398,7 @@ public static class Instances {
          *
          * @return A zipper for Vectors
          */
-        public static <T,R> Applicative<VectorKind.µ> zippingApplicative(){
+        public static <T,R> Applicative<vector> zippingApplicative(){
             BiFunction<VectorKind< Function<T, R>>,VectorKind<T>,VectorKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
@@ -428,9 +428,9 @@ public static class Instances {
          *
          * @return Type class with monad functions for Vectors
          */
-        public static <T,R> Monad<VectorKind.µ> monad(){
+        public static <T,R> Monad<vector> monad(){
 
-            BiFunction<Higher<VectorKind.µ,T>,Function<? super T, ? extends Higher<VectorKind.µ,R>>,Higher<VectorKind.µ,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<vector,T>,Function<? super T, ? extends Higher<vector,R>>,Higher<vector,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
@@ -450,7 +450,7 @@ public static class Instances {
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<VectorKind.µ> monadZero(){
+        public static <T,R> MonadZero<vector> monadZero(){
 
             return General.monadZero(monad(), VectorKind.widen(Vector.empty()));
         }
@@ -466,9 +466,9 @@ public static class Instances {
          * </pre>
          * @return Type class for combining Vectors by concatenation
          */
-        public static <T> MonadPlus<VectorKind.µ> monadPlus(){
+        public static <T> MonadPlus<vector> monadPlus(){
             Monoid<VectorKind<T>> m = Monoid.of(VectorKind.widen(Vector.empty()), Instances::concat);
-            Monoid<Higher<VectorKind.µ,T>> m2= (Monoid)m;
+            Monoid<Higher<vector,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
@@ -487,15 +487,15 @@ public static class Instances {
          * @param m Monoid to use for combining Vectors
          * @return Type class for combining Vectors
          */
-        public static <T> MonadPlus<VectorKind.µ> monadPlus(Monoid<VectorKind<T>> m){
-            Monoid<Higher<VectorKind.µ,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<vector> monadPlus(Monoid<VectorKind<T>> m){
+            Monoid<Higher<vector,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<VectorKind.µ> traverse(){
+        public static <C2,T> Traverse<vector> traverse(){
 
             BiFunction<Applicative<C2>,VectorKind<Higher<C2, T>>,Higher<C2, VectorKind<T>>> sequenceFn = (ap, list) -> {
 
@@ -513,7 +513,7 @@ public static class Instances {
 
 
             };
-            BiFunction<Applicative<C2>,Higher<VectorKind.µ,Higher<C2, T>>,Higher<C2, Higher<VectorKind.µ,T>>> sequenceNarrow  =
+            BiFunction<Applicative<C2>,Higher<vector,Higher<C2, T>>,Higher<C2, Higher<vector,T>>> sequenceNarrow  =
                     (a,b) -> VectorKind.widen2(sequenceFn.apply(a, VectorKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
@@ -533,9 +533,9 @@ public static class Instances {
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<VectorKind.µ> foldable(){
-            BiFunction<Monoid<T>,Higher<VectorKind.µ,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(VectorKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<VectorKind.µ,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(VectorKind.narrow(l)).reduce(m);
+        public static <T> Foldable<vector> foldable(){
+            BiFunction<Monoid<T>,Higher<vector,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(VectorKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<vector,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(VectorKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
@@ -548,7 +548,7 @@ private static  <T> VectorKind<T> concat(VectorKind<T> l1, VectorKind<T> l2){
         private static <T,R> VectorKind<R> ap(VectorKind<Function< T, R>> lt, VectorKind<T> list){
             return VectorKind.widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toVector());
         }
-        private static <T,R> Higher<VectorKind.µ,R> flatMap(Higher<VectorKind.µ,T> lt, Function<? super T, ? extends  Higher<VectorKind.µ,R>> fn){
+        private static <T,R> Higher<vector,R> flatMap(Higher<vector,T> lt, Function<? super T, ? extends  Higher<vector,R>> fn){
             return VectorKind.widen(VectorKind.narrow(lt).flatMap(fn.andThen(VectorKind::narrow)));
         }
         private static <T,R> VectorKind<R> map(VectorKind<T> lt, Function<? super T, ? extends R> fn){
diff --git a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
index 359bfc1b..c933dcf6 100644
--- a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
+++ b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
@@ -261,4 +261,13 @@ public FunctionalAdapter<tryType> adapter() {
         }
 
     }
+    public static enum lazy implements WitnessType<lazy> {
+        INSTANCE;
+
+        @Override
+        public FunctionalAdapter<lazy> adapter() {
+            return null;
+        }
+
+    }
 }
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java
index 4cd3cb6d..41b7bc78 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java
@@ -8,6 +8,8 @@
 import cyclops.function.Fn1;
 import cyclops.function.Lambda;
 import cyclops.function.Monoid;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.array;
 import io.vavr.collection.Array;
 import org.junit.Test;
 
@@ -32,7 +34,7 @@ public void functor(){
         
         ArrayKind<Integer> list = Arrays.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Arrays.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Arrays.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(ArrayKind::narrowK);
         
         assertThat(list,equalTo(Array.of("hello".length())));
@@ -52,8 +54,8 @@ public void applicative(){
         
         ArrayKind<Integer> list = Arrays.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Arrays.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h->Arrays.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h->Arrays.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Arrays.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(ArrayKind::narrowK);
         
         assertThat(list,equalTo(Array.of("hello".length()*2)));
@@ -69,7 +71,7 @@ public void monad(){
         
         ArrayKind<Integer> list = Arrays.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Arrays.Instances.monad().flatMap((String v) ->Arrays.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h->Arrays.Instances.monad().flatMap((String v) ->Arrays.Instances.unit().unit(v.length()), h))
                                      .convert(ArrayKind::narrowK);
         
         assertThat(list,equalTo(Array.of("hello".length())));
@@ -79,7 +81,7 @@ public void monadZeroFilter(){
         
         ArrayKind<String> list = Arrays.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Arrays.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h->Arrays.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(ArrayKind::narrowK);
         
         assertThat(list,equalTo(Array.of("hello")));
@@ -89,7 +91,7 @@ public void monadZeroFilterOut(){
         
         ArrayKind<String> list = Arrays.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Arrays.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h->Arrays.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(ArrayKind::narrowK);
         
         assertThat(list,equalTo(Array.empty()));
@@ -128,7 +130,7 @@ public void  foldRight(){
     
     @Test
     public void traverse(){
-       Maybe<Higher<ArrayKind.µ, Integer>> res = Arrays.Instances.traverse()
+       Maybe<Higher<array, Integer>> res = Arrays.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), ArrayKind.of(1,2,3))
                                                          .convert(Maybe::narrowK);
             
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java
index d388af4c..8c7870bf 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java
@@ -8,6 +8,8 @@
 
 import cyclops.companion.vavr.Futures;
 import com.aol.cyclops.vavr.hkt.FutureKind;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.future;
 import org.junit.Test;
 
 import com.aol.cyclops2.hkt.Higher;
@@ -34,7 +36,7 @@ public void functor(){
         
         FutureKind<Integer> opt = Futures.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Futures.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Futures.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(FutureKind::narrowK);
         
         assertThat(opt.get(),equalTo(Future.successful("hello".length()).get()));
@@ -57,8 +59,8 @@ public void applicative(){
         
         FutureKind<Integer> opt = Futures.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Futures.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Futures.Instances.applicative().ap(optFn, h))
+                                     .applyHKT(h-> Futures.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Futures.Instances.applicative().ap(optFn, h))
                                      .convert(FutureKind::narrowK);
         
         assertThat(opt.get(),equalTo(Future.successful("hello".length()*2).get()));
@@ -74,7 +76,7 @@ public void monad(){
         
         FutureKind<Integer> opt = Futures.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Futures.Instances.monad().flatMap((String v) -> Futures.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Futures.Instances.monad().flatMap((String v) -> Futures.Instances.unit().unit(v.length()), h))
                                      .convert(FutureKind::narrowK);
         
         assertThat(opt.get(),equalTo(Future.successful("hello".length()).get()));
@@ -84,7 +86,7 @@ public void monadZeroFilter(){
         
         FutureKind<String> opt = Futures.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Futures.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Futures.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(FutureKind::narrowK);
         
         assertThat(opt.get(),equalTo(Future.successful("hello").get()));
@@ -94,7 +96,7 @@ public void monadZeroFilterOut(){
         
         FutureKind<String> opt = Futures.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Futures.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Futures.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(FutureKind::narrowK);
         
         assertFalse(opt.isCompleted());
@@ -132,7 +134,7 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-       Maybe<Higher<FutureKind.µ, Integer>> res = Futures.Instances.traverse()
+       Maybe<Higher<future, Integer>> res = Futures.Instances.traverse()
                                                                  .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), FutureKind.successful(1))
                                                                  .convert(Maybe::narrowK);
        
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java
index 304cb441..789f39e9 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java
@@ -8,9 +8,12 @@
 import cyclops.companion.vavr.Lazys;
 import com.aol.cyclops.vavr.hkt.LazyKind;
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.vavr.Lazys.Instances;
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Monoid;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.lazy;
 import org.junit.Test;
 
 
@@ -22,7 +25,7 @@ public class LazyInstancesTest {
     @Test
     public void unit(){
         
-        LazyKind<String> opt = Lazys.Instances.unit()
+        LazyKind<String> opt = Instances.unit()
                                             .unit("hello")
                                             .convert(LazyKind::narrowK);
         
@@ -30,17 +33,18 @@ public void unit(){
     }
     @Test
     public void functor(){
-        
-        LazyKind<Integer> opt = Lazys.Instances.unit()
+        Higher<lazy,Integer> res =null;
+        LazyKind<Integer> x = LazyKind.narrowK(res);
+        LazyKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Lazys.Instances.functor().map((String v) ->v.length(), h))
-                                     .convert(LazyKind::narrowK);
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .convert(r-> LazyKind.narrowK(r));
         
         assertThat(opt,equalTo(Lazy.of(()->"hello".length())));
     }
     @Test
     public void apSimple(){
-        Lazys.Instances.applicative()
+        Instances.applicative()
             .ap(widen(Lazy.of(()-> l1(this::multiplyByTwo))),widen(Lazy.of(()->1)));
     }
     private int multiplyByTwo(int x){
@@ -49,30 +53,30 @@ private int multiplyByTwo(int x){
     @Test
     public void applicative(){
         
-        LazyKind<Fn1<Integer,Integer>> optFn =Lazys.Instances.unit()
+        LazyKind<Fn1<Integer,Integer>> optFn = Instances.unit()
                                                                   .unit(l1((Integer i) ->i*2))
                                                                   .convert(LazyKind::narrowK);
         
-        LazyKind<Integer> opt = Lazys.Instances.unit()
+        LazyKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Lazys.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h->Lazys.Instances.applicative().ap(optFn, h))
+                                     .applyHKT(h-> Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Instances.applicative().ap(optFn, h))
                                      .convert(LazyKind::narrowK);
         
         assertThat(opt,equalTo(Lazy.of(()->"hello".length()*2)));
     }
     @Test
     public void monadSimple(){
-       LazyKind<Integer> opt  = Lazys.Instances.monad()
+       LazyKind<Integer> opt  = Instances.monad()
                                             .<Integer,Integer>flatMap(i->widen(Lazy.of(()->i*2)), widen(Lazy.of(()->3)))
                                             .convert(LazyKind::narrowK);
     }
     @Test
     public void monad(){
         
-        LazyKind<Integer> opt = Lazys.Instances.unit()
+        LazyKind<Integer> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Lazys.Instances.monad().flatMap((String v) ->Lazys.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Instances.monad().flatMap((String v) -> Instances.unit().unit(v.length()), h))
                                      .convert(LazyKind::narrowK);
         
         assertThat(opt,equalTo(Lazy.of(()->"hello".length())));
@@ -80,9 +84,9 @@ public void monad(){
     @Test
     public void monadZeroFilter(){
         
-        LazyKind<String> opt = Lazys.Instances.unit()
+        LazyKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Lazys.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(LazyKind::narrowK);
         
         assertThat(opt,equalTo(Lazy.of(()->"hello")));
@@ -90,9 +94,9 @@ public void monadZeroFilter(){
     @Test
     public void monadZeroFilterOut(){
         
-        LazyKind<String> opt = Lazys.Instances.unit()
+        LazyKind<String> opt = Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Lazys.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(LazyKind::narrowK);
         
         assertThat(opt,equalTo(Lazy.of(()->null)));
@@ -100,7 +104,7 @@ public void monadZeroFilterOut(){
     
     @Test
     public void monadPlus(){
-        LazyKind<Integer> opt = Lazys.Instances.<Integer>monadPlus()
+        LazyKind<Integer> opt = Instances.<Integer>monadPlus()
                                       .plus(LazyKind.widen(Lazy.of(()->null)), LazyKind.widen(Lazy.of(()->10)))
                                       .convert(LazyKind::narrowK);
         assertThat(opt,equalTo(Lazy.of(()->10)));
@@ -109,28 +113,28 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<LazyKind<Integer>> m = Monoid.of(LazyKind.widen(Lazy.of(()->null)), (a, b)->a.get()==null ? b : a);
-        LazyKind<Integer> opt = Lazys.Instances.<Integer>monadPlus(m)
+        LazyKind<Integer> opt = Instances.<Integer>monadPlus(m)
                                       .plus(LazyKind.widen(Lazy.of(()->5)), LazyKind.widen(Lazy.of(()->10)))
                                       .convert(LazyKind::narrowK);
         assertThat(opt,equalTo(Lazy.of(()->5)));
     }
     @Test
     public void  foldLeft(){
-        int sum  = Lazys.Instances.foldable()
+        int sum  = Instances.foldable()
                         .foldLeft(0, (a,b)->a+b, LazyKind.widen(Lazy.of(()->4)));
         
         assertThat(sum,equalTo(4));
     }
     @Test
     public void  foldRight(){
-        int sum  = Lazys.Instances.foldable()
+        int sum  = Instances.foldable()
                         .foldRight(0, (a,b)->a+b, LazyKind.widen(Lazy.of(()->1)));
         
         assertThat(sum,equalTo(1));
     }
     @Test
     public void traverse(){
-       Maybe<Higher<LazyKind.µ, Integer>> res = Lazys.Instances.traverse()
+       Maybe<Higher<lazy, Integer>> res = Instances.traverse()
                                                                    .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), LazyKind.of(()->1))
                                                                  .convert(Maybe::narrowK);
        
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ListTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ListTest.java
index 9cb7e29a..257bb3ee 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ListTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ListTest.java
@@ -11,6 +11,8 @@
 import com.aol.cyclops.vavr.hkt.ListKind;
 
 
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.list;
 import cyclops.stream.ReactiveSeq;
 import org.junit.Test;
 
@@ -36,7 +38,7 @@ public void functor(){
         
         ListKind<Integer> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello".length())));
@@ -56,8 +58,8 @@ public void applicative(){
         
         ListKind<Integer> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Lists.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h-> Lists.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Lists.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello".length()*2)));
@@ -73,7 +75,7 @@ public void monad(){
         
         ListKind<Integer> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.monad().flatMap((String v) -> Lists.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Lists.Instances.monad().flatMap((String v) -> Lists.Instances.unit().unit(v.length()), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello".length())));
@@ -83,7 +85,7 @@ public void monadZeroFilter(){
         
         ListKind<String> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Lists.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello")));
@@ -93,7 +95,7 @@ public void monadZeroFilterOut(){
         
         ListKind<String> list = Lists.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Lists.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Lists.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(ListKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList()));
@@ -106,17 +108,7 @@ public void monadPlus(){
                                       .convert(ListKind::narrowK);
         assertThat(list.toJavaList(),equalTo(Arrays.asList(10)));
     }
-/**
-    @Test
-    public void monadPlusNonEmpty(){
-        
-        Monoid<ListKind<Integer>> m = Monoid.of(ListKind.widen(List.empty()), (a,b)->a.isEmpty() ? b : a);
-        ListKind<Integer> list = Lists.Instances.<Integer>monadPlus(m)
-                                      .plus(ListKind.widen(List.of(5)), ListKind.widen(List.of(10)))
-                                      .convert(ListKind::narrowK);
-        assertThat(list,equalTo(Arrays.asList(5)));
-    }
-**/
+
     @Test
     public void  foldLeft(){
         int sum  = Lists.Instances.foldable()
@@ -133,7 +125,7 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-       Maybe<Higher<ListKind.µ, Integer>> res = Lists.Instances.traverse()
+       Maybe<Higher<list, Integer>> res = Lists.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), ListKind.just(1,2,3))
                                                          .convert(Maybe::narrowK);
        
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java
index 25d906dd..cdfd78bd 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java
@@ -6,6 +6,8 @@
 
 import cyclops.companion.vavr.Options;
 import com.aol.cyclops.vavr.hkt.OptionKind;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.option;
 import org.junit.Test;
 
 import com.aol.cyclops2.hkt.Higher;
@@ -32,7 +34,7 @@ public void functor(){
         
         OptionKind<Integer> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Options.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.of("hello".length())));
@@ -52,8 +54,8 @@ public void applicative(){
         
         OptionKind<Integer> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Options.Instances.applicative().ap(optFn, h))
+                                     .applyHKT(h-> Options.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Options.Instances.applicative().ap(optFn, h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.of("hello".length()*2)));
@@ -69,7 +71,7 @@ public void monad(){
         
         OptionKind<Integer> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.monad().flatMap((String v) -> Options.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Options.Instances.monad().flatMap((String v) -> Options.Instances.unit().unit(v.length()), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.of("hello".length())));
@@ -79,7 +81,7 @@ public void monadZeroFilter(){
         
         OptionKind<String> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Options.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.of("hello")));
@@ -89,7 +91,7 @@ public void monadZeroFilterOut(){
         
         OptionKind<String> opt = Options.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Options.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Options.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(OptionKind::narrowK);
         
         assertThat(opt,equalTo(Option.none()));
@@ -127,7 +129,7 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-       Maybe<Higher<OptionKind.µ, Integer>> res = Options.Instances.traverse()
+       Maybe<Higher<option, Integer>> res = Options.Instances.traverse()
                                                                  .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), OptionKind.of(1))
                                                                  .convert(Maybe::narrowK);
        
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java
index 3a2f3a03..985f2990 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java
@@ -8,6 +8,8 @@
 
 import cyclops.companion.vavr.Queues;
 import com.aol.cyclops.vavr.hkt.QueueKind;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.queue;
 import org.junit.Test;
 
 import com.aol.cyclops2.hkt.Higher;
@@ -34,7 +36,7 @@ public void functor(){
         
         QueueKind<Integer> list = Queues.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Queues.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Queues.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(QueueKind::narrowK);
         
         assertThat(list,equalTo(Queue.of("hello".length())));
@@ -54,8 +56,8 @@ public void applicative(){
         
         QueueKind<Integer> list = Queues.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Queues.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h->Queues.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h->Queues.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Queues.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(QueueKind::narrowK);
         
         assertThat(list,equalTo(Queue.of("hello".length()*2)));
@@ -71,7 +73,7 @@ public void monad(){
         
         QueueKind<Integer> list = Queues.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Queues.Instances.monad().flatMap((String v) ->Queues.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h->Queues.Instances.monad().flatMap((String v) ->Queues.Instances.unit().unit(v.length()), h))
                                      .convert(QueueKind::narrowK);
         
         assertThat(list,equalTo(Queue.of("hello".length())));
@@ -81,7 +83,7 @@ public void monadZeroFilter(){
         
         QueueKind<String> list = Queues.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Queues.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h->Queues.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(QueueKind::narrowK);
         
         assertThat(list,equalTo(Queue.of("hello")));
@@ -91,7 +93,7 @@ public void monadZeroFilterOut(){
         
         QueueKind<String> list = Queues.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Queues.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h->Queues.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(QueueKind::narrowK);
         
         assertThat(list,equalTo(Queue.empty()));
@@ -130,7 +132,7 @@ public void  foldRight(){
     
     @Test
     public void traverse(){
-       Maybe<Higher<QueueKind.µ, Integer>> res = Queues.Instances.traverse()
+       Maybe<Higher<queue, Integer>> res = Queues.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), QueueKind.of(1,2,3))
                                                          .convert(Maybe::narrowK);
             
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/StreamTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/StreamTest.java
index e51b00ad..612aae18 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/StreamTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/StreamTest.java
@@ -10,6 +10,8 @@
 import cyclops.companion.vavr.Streams;
 import com.aol.cyclops.vavr.hkt.StreamKind;
 
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.stream;
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.functor.Functor;
@@ -35,10 +37,10 @@ public void unit(){
     }
     @Test
     public void functor(){
-        Pure<StreamKind.µ> unit = Streams.Instances.unit();
+        Pure<stream> unit = Streams.Instances.unit();
         StreamKind<Integer> list = Streams.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Streams.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Streams.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(StreamKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello".length())));
@@ -46,11 +48,11 @@ public void functor(){
     @Test
     public void functor2(){
 
-        Pure<StreamKind.µ> pure = Streams.Instances.unit();
-        Functor<StreamKind.µ> functor = Streams.Instances.functor();
+        Pure<stream> pure = Streams.Instances.unit();
+        Functor<stream> functor = Streams.Instances.functor();
 
         StreamKind<Integer> list = pure.unit("hello")
-                                       .apply(h->functor.map((String v) ->v.length(), h))
+                                       .applyHKT(h->functor.map((String v) ->v.length(), h))
                                        .convert(StreamKind::narrowK);
 
 
@@ -71,8 +73,8 @@ public void applicative(){
         
         StreamKind<Integer> list = Streams.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Streams.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h->Streams.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h->Streams.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h->Streams.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(StreamKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello".length()*2)));
@@ -88,7 +90,7 @@ public void monad(){
         
         StreamKind<Integer> list = Streams.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Streams.Instances.monad().flatMap((String v) ->Streams.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h->Streams.Instances.monad().flatMap((String v) ->Streams.Instances.unit().unit(v.length()), h))
                                      .convert(StreamKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello".length())));
@@ -98,7 +100,7 @@ public void monadZeroFilter(){
         
         StreamKind<String> list = Streams.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Streams.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h->Streams.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(StreamKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList("hello")));
@@ -108,7 +110,7 @@ public void monadZeroFilterOut(){
         
         StreamKind<String> list = Streams.Instances.unit()
                                      .unit("hello")
-                                     .apply(h->Streams.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h->Streams.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(StreamKind::narrowK);
         
         assertThat(list.toJavaList(),equalTo(Arrays.asList()));
@@ -121,17 +123,7 @@ public void monadPlus(){
                                       .convert(StreamKind::narrowK);
         assertThat(list.toJavaList(),equalTo(Arrays.asList(10)));
     }
-/**
-    @Test
-    public void monadPlusNonEmpty(){
-        
-        Monoid<StreamKind<Integer>> m = Monoid.of(StreamKind.widen(Stream.empty()), (a,b)->a.isEmpty() ? b : a);
-        StreamKind<Integer> list = Streams.Instances.<Integer>monadPlus(m)
-                                      .plus(StreamKind.widen(Stream.of(5)), StreamKind.widen(Stream.of(10)))
-                                      .convert(StreamKind::narrowK);
-        assertThat(list,equalTo(Arrays.asList(5)));
-    }
-**/
+
     @Test
     public void  foldLeft(){
         int sum  = Streams.Instances.foldable()
@@ -148,7 +140,7 @@ public void  foldRight(){
     }
     @Test
     public void traverse(){
-       Maybe<Higher<StreamKind.µ, Integer>> res = Streams.Instances.traverse()
+       Maybe<Higher<stream, Integer>> res = Streams.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), StreamKind.just(1,2,3))
                                                          .convert(Maybe::narrowK);
        
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java
index 4da26300..f7fa0eeb 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java
@@ -8,6 +8,8 @@
 
 import cyclops.companion.vavr.Vectors;
 import com.aol.cyclops.vavr.hkt.VectorKind;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.vector;
 import org.junit.Test;
 
 import com.aol.cyclops2.hkt.Higher;
@@ -34,7 +36,7 @@ public void functor(){
         
         VectorKind<Integer> list = Vectors.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Vectors.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Vectors.Instances.functor().map((String v) ->v.length(), h))
                                      .convert(VectorKind::narrowK);
         
         assertThat(list,equalTo(Vector.of("hello".length())));
@@ -54,8 +56,8 @@ public void applicative(){
         
         VectorKind<Integer> list = Vectors.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Vectors.Instances.functor().map((String v) ->v.length(), h))
-                                     .apply(h-> Vectors.Instances.zippingApplicative().ap(listFn, h))
+                                     .applyHKT(h-> Vectors.Instances.functor().map((String v) ->v.length(), h))
+                                     .applyHKT(h-> Vectors.Instances.zippingApplicative().ap(listFn, h))
                                      .convert(VectorKind::narrowK);
         
         assertThat(list,equalTo(Vector.of("hello".length()*2)));
@@ -71,7 +73,7 @@ public void monad(){
         
         VectorKind<Integer> list = Vectors.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Vectors.Instances.monad().flatMap((String v) -> Vectors.Instances.unit().unit(v.length()), h))
+                                     .applyHKT(h-> Vectors.Instances.monad().flatMap((String v) -> Vectors.Instances.unit().unit(v.length()), h))
                                      .convert(VectorKind::narrowK);
         
         assertThat(list,equalTo(Vector.of("hello".length())));
@@ -81,7 +83,7 @@ public void monadZeroFilter(){
         
         VectorKind<String> list = Vectors.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Vectors.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
+                                     .applyHKT(h-> Vectors.Instances.monadZero().filter((String t)->t.startsWith("he"), h))
                                      .convert(VectorKind::narrowK);
         
         assertThat(list,equalTo(Vector.of("hello")));
@@ -91,7 +93,7 @@ public void monadZeroFilterOut(){
         
         VectorKind<String> list = Vectors.Instances.unit()
                                      .unit("hello")
-                                     .apply(h-> Vectors.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
+                                     .applyHKT(h-> Vectors.Instances.monadZero().filter((String t)->!t.startsWith("he"), h))
                                      .convert(VectorKind::narrowK);
         
         assertThat(list,equalTo(Vector.empty()));
@@ -130,7 +132,7 @@ public void  foldRight(){
     
     @Test
     public void traverse(){
-       Maybe<Higher<VectorKind.µ, Integer>> res = Vectors.Instances.traverse()
+       Maybe<Higher<vector, Integer>> res = Vectors.Instances.traverse()
                                                          .traverseA(Maybe.Instances.applicative(), (Integer a)->Maybe.just(a*2), VectorKind.of(1,2,3))
                                                          .convert(Maybe::narrowK);
             
diff --git a/gradle.properties b/gradle.properties
index 21510b5f..42b7d9c1 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,6 +1,6 @@
-version=9.0.0-MI4
+version=9.0.0-MI5
 lombokVersion=1.16.2
-cyclopsReactVersion=2.0.0-RC8
+cyclopsReactVersion=2.0.0-FINAL
 vavrVersion=0.9.0
 guavaVersion=20.0
 functionalJavaVersion=4.5

From 916ed1f625c64ecd4ecedb789d0e707be5b58e93 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Tue, 4 Jul 2017 22:21:28 +0100
Subject: [PATCH 03/30] Vavr Try support

---
 .../functionaljava/hkt/EitherKind.java        | 187 ++++++++++
 .../companion/functionaljava/Eithers.java     | 316 +++++++++++++++-
 .../com/aol/cyclops/vavr/hkt/ArrayKind.java   |  16 +
 .../com/aol/cyclops/vavr/hkt/EitherKind.java  | 126 +++++++
 .../com/aol/cyclops/vavr/hkt/FutureKind.java  |  20 +-
 .../com/aol/cyclops/vavr/hkt/LazyKind.java    |  19 +-
 .../com/aol/cyclops/vavr/hkt/TryKind.java     | 154 ++++++++
 .../src/main/java/cyclops/VavrConverters.java |   2 +
 .../java/cyclops/companion/vavr/Arrays.java   |  97 ++++-
 .../java/cyclops/companion/vavr/Eithers.java  | 313 +++++++++++++++-
 .../java/cyclops/companion/vavr/Futures.java  |  78 +++-
 .../java/cyclops/companion/vavr/Lazys.java    |  79 +++-
 .../java/cyclops/companion/vavr/Trys.java     | 337 +++++++++++++++++-
 13 files changed, 1724 insertions(+), 20 deletions(-)
 create mode 100644 cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
 create mode 100644 cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java
 create mode 100644 cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java

diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
new file mode 100644
index 00000000..6c9d031d
--- /dev/null
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
@@ -0,0 +1,187 @@
+package com.aol.cyclops.functionaljava.hkt;
+
+
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.hkt.Higher2;
+import com.aol.cyclops2.types.foldable.To;
+import cyclops.companion.functionaljava.Eithers;
+import cyclops.control.Xor;
+import cyclops.conversion.functionaljava.ToCyclopsReact;
+import cyclops.monads.FJWitness.either;
+import cyclops.monads.Witness;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.XorT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import fj.F;
+import fj.F0;
+import fj.data.*;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+
+import java.util.function.Function;
+
+@AllArgsConstructor(access= AccessLevel.PRIVATE)
+public class EitherKind<L,R> implements To<EitherKind<L,R>>,
+                                        Higher2<either,L,R> {
+
+    private final Either<L,R> boxed;
+
+    public <R2> EitherKind<L,R2> fold(Function<? super Either<? super L,? super R>,? extends Either<L,R2>> op){
+        return widen(op.apply(boxed));
+    }
+    public static <L,R> EitherKind<L,R> widen(final Either<L,R> either) {
+        return new EitherKind<>(either);
+    }
+    public static <L,R> EitherKind<L,R> right(final R right) {
+        return new EitherKind<>(Either.right(right));
+    }
+    public static <L, R> Either<L, R> narrowK2(final Higher2<either, L, R> xor) {
+        return (Either<L, R>)xor;
+    }
+    public static <L, R> Either<L, R> narrowK(final Higher<Higher<either, L>, R> either) {
+        return (Either<L, R>)either;
+    }
+    public Active<Higher<either,L>,R> allTypeclasses(){
+        return Active.of(this, Eithers.Instances.definitions());
+    }
+    public <W2,R2> Nested<Higher<either,L>,W2,R2> mapM(Function<? super R,? extends Higher<W2,R2>> fn, InstanceDefinitions<W2> defs){
+        return Nested.of(widen(bimap(l->l,r->fn.apply(r))), Eithers.Instances.definitions(), defs);
+    }
+    public <W extends WitnessType<W>> XorT<W, L,R> liftM(W witness) {
+        return XorT.of(witness.adapter().unit(ToCyclopsReact.xor(boxed)));
+    }
+
+    public Either<L, R>.LeftProjection<L, R> left() {
+        return boxed.left();
+    }
+
+    public Either<L, R>.RightProjection<L, R> right() {
+        return boxed.right();
+    }
+
+    public boolean isLeft() {
+        return boxed.isLeft();
+    }
+
+    public boolean isRight() {
+        return boxed.isRight();
+    }
+
+    public <X> X either(F<L, X> left, F<R, X> right) {
+        return boxed.either(left, right);
+    }
+
+    public <X, Y> Either<X, Y> bimap(F<L, X> left, F<R, Y> right) {
+        return boxed.bimap(left, right);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return boxed.equals(other);
+    }
+
+    @Override
+    public int hashCode() {
+        return boxed.hashCode();
+    }
+
+    public Either<R, L> swap() {
+        return boxed.swap();
+    }
+
+
+    public static <A, B, X> F<F<A, X>, F<Either<A, B>, Either<X, B>>> leftMap_() {
+        return Either.leftMap_();
+    }
+
+    public static <A, B, X> F<F<B, X>, F<Either<A, B>, Either<A, X>>> rightMap_() {
+        return Either.rightMap_();
+    }
+
+    public static <A, B> Either<A, B> joinLeft(Either<Either<A, B>, B> e) {
+        return Either.joinLeft(e);
+    }
+
+    public static <A, B> Either<A, B> joinRight(Either<A, Either<A, B>> e) {
+        return Either.joinRight(e);
+    }
+
+    public static <A, X> Either<List<A>, X> sequenceLeft(List<Either<A, X>> a) {
+        return Either.sequenceLeft(a);
+    }
+
+    public static <B, X> Either<X, List<B>> sequenceRight(List<Either<X, B>> a) {
+        return Either.sequenceRight(a);
+    }
+
+    public <C> List<Either<L, C>> traverseListRight(F<R, List<C>> f) {
+        return boxed.traverseListRight(f);
+    }
+
+    public <C> List<Either<C, R>> traverseListLeft(F<L, List<C>> f) {
+        return boxed.traverseListLeft(f);
+    }
+
+    public <C> IO<Either<L, C>> traverseIORight(F<R, IO<C>> f) {
+        return boxed.traverseIORight(f);
+    }
+
+    public <C> IO<Either<C, R>> traverseIOLeft(F<L, IO<C>> f) {
+        return boxed.traverseIOLeft(f);
+    }
+
+    public <C> Option<Either<L, C>> traverseOptionRight(F<R, Option<C>> f) {
+        return boxed.traverseOptionRight(f);
+    }
+
+    public <C> Option<Either<C, R>> traverseOptionLeft(F<L, Option<C>> f) {
+        return boxed.traverseOptionLeft(f);
+    }
+
+    public <C> Stream<Either<L, C>> traverseStreamRight(F<R, Stream<C>> f) {
+        return boxed.traverseStreamRight(f);
+    }
+
+    public <C> Stream<Either<C, R>> traverseStreamLeft(F<L, Stream<C>> f) {
+        return boxed.traverseStreamLeft(f);
+    }
+
+    public static <A> A reduce(Either<A, A> e) {
+        return Either.reduce(e);
+    }
+
+    public static <A, B> Either<A, B> iif(boolean c, F0<B> right, F0<A> left) {
+        return Either.iif(c, right, left);
+    }
+
+    public static <A, B> List<A> lefts(List<Either<A, B>> es) {
+        return Either.lefts(es);
+    }
+
+    public static <A, B> List<B> rights(List<Either<A, B>> es) {
+        return Either.rights(es);
+    }
+
+    @Override
+    public String toString() {
+        return boxed.toString();
+    }
+
+    public static <L,R> EitherKind<L,R> left(final L left) {
+        return new EitherKind<>(Either.left(left));
+    }
+
+    public static <A, B> F<A, Either<A, B>> left_() {
+        return Either.left_();
+    }
+
+    public static <A, B> F<B, Either<A, B>> right_() {
+        return Either.right_();
+    }
+
+
+
+
+}
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
index fb680877..84a5cf17 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
@@ -1,7 +1,13 @@
 package cyclops.companion.functionaljava;
 
 
+import com.aol.cyclops.functionaljava.hkt.EitherKind;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.hkt.Higher2;
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.Monoids;
+import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.monads.FJWitness;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import cyclops.conversion.functionaljava.ToCyclopsReact;
@@ -13,8 +19,22 @@
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
+import cyclops.monads.FJWitness.either;
+import cyclops.monads.Witness;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
 
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
+import cyclops.typeclasses.comonad.ComonadByPure;
+import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
+import cyclops.typeclasses.functor.Functor;
+import cyclops.typeclasses.monad.*;
 import fj.data.Either;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
@@ -31,8 +51,13 @@
  */
 @UtilityClass
 public class Eithers {
-   
-    public static <T> AnyMValue<FJWitness.either,T> anyM(Either<?,T> either) {
+
+    public static <L, R> Either<L, R> xor(Xor<L, R> value) {
+        Xor<L, R> xor = (Xor) value.toXor();
+        return xor.visit(l -> Either.left(l), r -> Either.right(r));
+    }
+
+    public static <T> AnyMValue<either,T> anyM(Either<?,T> either) {
         return AnyM.ofValue(either, FJWitness.either.INSTANCE);
     }
     /**
@@ -233,7 +258,7 @@ public static <L,T> Either<L,ListX<T>> sequencePresent(final CollectionX<Either<
      * @return  Either with a List of values
      */
     public static <L,T> Either<L,ReactiveSeq<T>> sequence(final Stream<Either<L,T>> opts) {
-        return AnyM.sequence(opts.map(Eithers::anyM), FJWitness.either.INSTANCE)
+        return AnyM.sequence(opts.map(Eithers::anyM), either.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(FJWitness::either);
 
@@ -420,6 +445,291 @@ public static <L,T> Either<L,T> narrow(final Either<L,? extends T> eitheral) {
         return (Either<L,T>) eitheral;
     }
 
+    public static <L,R> Active<Higher<either,L>,R> allTypeclasses(Either<L,R> either){
+        return Active.of(EitherKind.widen(either), Eithers.Instances.definitions());
+    }
+    public static <L,R,W2,R2> Nested<Higher<either,L>,W2,R2> mapM(Either<L,R> either,Function<? super R,? extends Higher<W2,R2>> fn, InstanceDefinitions<W2> defs){
+        Either<L, Higher<W2, R2>> e = either.bimap(i -> i, i -> fn.apply(i));
+        EitherKind<L, Higher<W2, R2>> ek = EitherKind.widen(e);
+        return Nested.of(ek, Eithers.Instances.definitions(), defs);
+    }
+    public <L,R,W extends WitnessType<W>> XorT<W, L, R> liftM(Either<L,R> either,W witness) {
+        return XorT.of(witness.adapter().unit(ToCyclopsReact.xor(either)));
+    }
+
+    public static class Instances {
+
+        public static <L> InstanceDefinitions<Higher<either, L>> definitions(){
+            return new InstanceDefinitions<Higher<either, L>>() {
+                @Override
+                public <T, R> Functor<Higher<either, L>> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<Higher<either, L>> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<Higher<either, L>> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<Higher<either, L>> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<Higher<either, L>>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<Higher<either, L>>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<Higher<either, L>>> monadPlus(Monoid<Higher<Higher<either, L>, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<Higher<either, L>>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<Higher<either, L>>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<Higher<either, L>>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<Higher<either, L>>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
+        public static <L> Functor<Higher<either, L>> functor() {
+            return new Functor<Higher<either, L>>() {
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.bimap(i->i,r->fn.apply(r)));
+                }
+            };
+        }
+        public static <L> Pure<Higher<either, L>> unit() {
+            return new Pure<Higher<either, L>>() {
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return EitherKind.right(value);
+                }
+            };
+        }
+        public static <L> Applicative<Higher<either, L>> applicative() {
+            return new Applicative<Higher<either, L>>() {
+
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    Either<L,T>  either = EitherKind.narrowK(apply);
+                    Either<L, ? extends Function<T, R>> eitherFn = EitherKind.narrowK(fn);
+                    return EitherKind.widen(Eithers.xor(ToCyclopsReact.xor(eitherFn).combine(ToCyclopsReact.xor(either),(a,b)->a.apply(b))));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Monad<Higher<either, L>> monad() {
+            return new Monad<Higher<either, L>>() {
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Traverse<Higher<either, L>> traverse() {
+            return new Traverse<Higher<either, L>>() {
+
+                @Override
+                public <C2, T, R> Higher<C2, Higher<Higher<either, L>, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> maybe = EitherKind.narrowK(ds);
+                    return maybe.either(left->  applicative.unit(EitherKind.<L,R>left(left)),
+                            right->applicative.map(m->EitherKind.right(m), fn.apply(right)));
+                }
+
+                @Override
+                public <C2, T> Higher<C2, Higher<Higher<either, L>, T>> sequenceA(Applicative<C2> applicative, Higher<Higher<either, L>, Higher<C2, T>> ds) {
+                    return traverseA(applicative,Function.identity(),ds);
+                }
+
+
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Foldable<Higher<either, L>> foldable() {
+            return new Foldable<Higher<either, L>>() {
+
+
+                @Override
+                public <T> T foldRight(Monoid<T> monoid, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return ToCyclopsReact.xor(either).foldRight(monoid);
+                }
+
+                @Override
+                public <T> T foldLeft(Monoid<T> monoid, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return ToCyclopsReact.xor(either).foldLeft(monoid);
+                }
+            };
+        }
+        public static <L> MonadZero<Higher<either, L>> monadZero() {
+            return new MonadZero<Higher<either, L>>() {
+
+                @Override
+                public Higher<Higher<either, L>, ?> zero() {
+                    return EitherKind.left(null);
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> MonadPlus<Higher<either, L>> monadPlus() {
+            Monoid m = Monoids.firstPrimaryXor((Either)EitherKind.narrowK(Instances.<L>monadZero().zero()));
+
+            return monadPlus(m);
+        }
+        public static <L,T> MonadPlus<Higher<either, L>> monadPlus(Monoid<Higher<Higher<either, L>, T>> m) {
+            return new MonadPlus<Higher<either, L>>() {
+
+                @Override
+                public Monoid<Higher<Higher<either, L>, ?>> monoid() {
+                    return (Monoid)m;
+                }
+
+                @Override
+                public Higher<Higher<either, L>, ?> zero() {
+                    return Instances.<L>monadZero().zero();
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Comonad<Higher<either, L>> comonad() {
+            return new ComonadByPure<Higher<either, L>>() {
+
+
+                @Override
+                public <T> T extract(Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return either.right().value();
+                }
+
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+    }
 
 
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
index 02e0dfaf..83f21242 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
@@ -2,13 +2,21 @@
 
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.Unwrapable;
+import cyclops.companion.vavr.Arrays;
+import cyclops.companion.vavr.Lazys;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.array;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import io.vavr.Lazy;
 import io.vavr.collection.Array;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.experimental.Delegate;
 
+import java.util.function.Function;
+
 /**
  * Simulates Higher Kinded Types for Array's
  * 
@@ -22,6 +30,14 @@
 public  class ArrayKind<T> implements Higher<array, T>{
 
 
+    public Active<array,T> allTypeclasses(){
+        return Active.of(this, Arrays.Instances.definitions());
+    }
+    public <W2,R> Nested<array,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Array<Higher<W2, R>> e = map(fn);
+        ArrayKind<Higher<W2, R>> lk = ArrayKind.widen(e);
+        return Nested.of(lk, Arrays.Instances.definitions(), defs);
+    }
     public static <T> ArrayKind<T> of(T element) {
         return  widen(Array.of(element));
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java
new file mode 100644
index 00000000..2846eda0
--- /dev/null
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java
@@ -0,0 +1,126 @@
+package com.aol.cyclops.vavr.hkt;
+
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.hkt.Higher2;
+import com.aol.cyclops2.types.foldable.To;
+import cyclops.companion.vavr.Eithers;
+import cyclops.conversion.vavr.ToCyclopsReact;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.either;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.XorT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+
+import io.vavr.CheckedFunction0;
+
+import io.vavr.Tuple2;
+import io.vavr.Value;
+import io.vavr.collection.*;
+import io.vavr.collection.Iterator;
+import io.vavr.collection.PriorityQueue;
+import io.vavr.collection.Queue;
+import io.vavr.collection.SortedMap;
+import io.vavr.collection.SortedSet;
+import io.vavr.collection.Vector;
+import io.vavr.control.Either;
+import io.vavr.control.Option;
+import io.vavr.control.Try;
+import io.vavr.control.Validation;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.util.*;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.*;
+import java.util.stream.Collector;
+import java.util.stream.Stream;
+
+
+public interface EitherKind<L,R> extends Either<L,R>,To<EitherKind<L,R>>,
+                                        Higher2<either,L,R> {
+
+    default <R2> EitherKind<L,R2> fold(Function<? super Either<? super L,? super R>,? extends Either<L,R2>> op){
+        return widen(op.apply(this));
+    }
+    public static <L,R> EitherKind<L,R> widen(final Either<L,R> either) {
+        return new Box<>(either);
+    }
+    public static <L,R> EitherKind<L,R> rightK(final R right) {
+        return new Box<>(Either.right(right));
+    }
+    public static <L,R> EitherKind<L,R> leftK(final L left) {
+        return new Box<>(Either.left(left));
+    }
+    public static <L, R> Either<L, R> narrowK2(final Higher2<either, L, R> xor) {
+        return (Either<L, R>)xor;
+    }
+    public static <L, R> Either<L, R> narrowK(final Higher<Higher<either, L>, R> either) {
+        return (Either<L, R>)either;
+    }
+    default Active<Higher<either,L>,R> allTypeclasses(){
+        return Active.of(this, Eithers.Instances.definitions());
+    }
+    default <W2,R2> Nested<Higher<either,L>,W2,R2> mapM(Function<? super R,? extends Higher<W2,R2>> fn, InstanceDefinitions<W2> defs){
+        return Nested.of(widen(bimap(l->l,r->fn.apply(r))), Eithers.Instances.definitions(), defs);
+    }
+    default <W extends WitnessType<W>> XorT<W, L,R> liftM(W witness) {
+        return XorT.of(witness.adapter().unit(ToCyclopsReact.xor(this)));
+    }
+    public static <L1, R1> Either<L1, R1> right(R1 right) {
+        return Either.right(right);
+    }
+
+    public static <L1, R1> Either<L1, R1> left(L1 left) {
+        return Either.left(left);
+    }
+
+    public static <L1, R1> Either<L1, R1> narrow(Either<? extends L1, ? extends R1> either) {
+        return Either.narrow(either);
+    }
+
+    @AllArgsConstructor(access = AccessLevel.PRIVATE)
+    static final class Box<L,R> implements EitherKind<L,R> {
+
+        private final Either<L,R> boxed;
+
+        public Either<L,R> narrow() {
+            return boxed;
+        }
+
+        @Override
+        public L getLeft() {
+            return boxed.getLeft();
+        }
+
+        @Override
+        public boolean isLeft() {
+            return false;
+        }
+
+        @Override
+        public boolean isRight() {
+            return boxed.isRight();
+        }
+
+        @Override
+        public R get() {
+            return boxed.get();
+        }
+
+        @Override
+        public String stringPrefix() {
+            return boxed.stringPrefix();
+        }
+    }
+
+
+
+
+}
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
index a78a66cd..adaee3d7 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
@@ -7,12 +7,21 @@
 import java.util.function.Function;
 
 
+import cyclops.companion.vavr.Arrays;
+import cyclops.companion.vavr.Futures;
 import cyclops.conversion.vavr.FromCyclopsReact;
 
 import com.aol.cyclops2.hkt.Higher;
 
+import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.future;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.FutureT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import io.vavr.collection.Array;
 import io.vavr.concurrent.Future;
 import io.vavr.concurrent.Promise;
 import io.vavr.control.Option;
@@ -32,8 +41,15 @@
 
 public interface FutureKind<T> extends Higher<future, T>, Future<T> {
 
-
-    
+    default Active<future,T> allTypeclasses(){
+        return Active.of(this, Futures.Instances.definitions());
+    }
+    default <W2,R> Nested<future,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Futures.mapM(this,fn,defs);
+    }
+    default <W extends WitnessType<W>> FutureT<W, T> liftM(W witness) {
+        return FutureT.of(witness.adapter().unit(ToCyclopsReact.future(this)));
+    }
     public static <T> FutureKind<T> failed(Throwable exception){
         return widen(Future.failed(exception));
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
index faa97546..c3ed5f1d 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
@@ -7,6 +7,8 @@
 import java.util.function.Supplier;
 
 
+import cyclops.companion.vavr.Eithers;
+import cyclops.companion.vavr.Lazys;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 
@@ -15,6 +17,11 @@
 
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.lazy;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.EvalT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.vavr.Lazy;
 import io.vavr.collection.Iterator;
 import io.vavr.control.Option;
@@ -32,8 +39,18 @@
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final  class LazyKind<T> implements Higher<lazy, T> {
-    
 
+    public  Active<lazy,T> allTypeclasses(){
+        return Active.of(this, Lazys.Instances.definitions());
+    }
+    public <W2,R> Nested<lazy,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Lazy<Higher<W2, R>> e = map(fn);
+        LazyKind<Higher<W2, R>> lk = LazyKind.widen(e);
+        return Nested.of(lk, Lazys.Instances.definitions(), defs);
+    }
+    public <T,W extends WitnessType<W>> EvalT<W, T> liftM(Lazy<T> lazy, W witness) {
+        return EvalT.of(witness.adapter().unit(ToCyclopsReact.eval(lazy)));
+    }
     /**
      * Convert the raw Higher Kinded Type for MaybeType types into the MaybeType type definition class
      * 
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
new file mode 100644
index 00000000..e7a3e980
--- /dev/null
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
@@ -0,0 +1,154 @@
+package com.aol.cyclops.vavr.hkt;
+
+
+import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.vavr.Futures;
+import cyclops.companion.vavr.Trys;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.ToCyclopsReact;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.future;
+import cyclops.monads.VavrWitness.tryType;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.FutureT;
+import cyclops.monads.transformers.XorT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import io.vavr.concurrent.Future;
+import io.vavr.concurrent.Promise;
+import io.vavr.control.Option;
+import io.vavr.control.Try;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+
+import java.util.concurrent.ExecutorService;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * Simulates Higher Kinded Types for Vavr Future's
+ * 
+ * FutureKind is a Future and a Higher Kinded Type (future,T)
+ * 
+ * @author johnmcclean
+ *
+ * @param <T> Data type stored within the Future
+ */
+
+public interface TryKind<T> extends Higher<tryType, T>, Try<T> {
+
+    default Active<tryType,T> allTypeclasses(){
+        return Active.of(this, Trys.Instances.definitions());
+    }
+    default <W2,R> Nested<tryType,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Trys.mapM(this,fn,defs);
+    }
+    default <W extends WitnessType<W>> XorT<W,Throwable, T> liftM(W witness) {
+        return XorT.of(witness.adapter().unit(ToCyclopsReact.toTry(this).asXor()));
+    }
+    
+    public static <T> TryKind<T> failed(Throwable exception){
+        return widen(Try.failure(exception));
+    }
+    /**
+     * Construct a HKT encoded completed Future
+     * 
+     * @param value To encode inside a HKT encoded Future
+     * @return Completed HKT encoded Future
+     */
+    public static <T> TryKind<T> successful(T value){
+        return widen(Try.success(value));
+    }
+
+    /**
+     * Convert a Future to a simulated HigherKindedType that captures Future nature
+     * and Future element data type separately. Recover via @see FutureKind#narrow
+     * 
+     * If the supplied Future implements FutureKind it is returned already, otherwise it
+     * is wrapped into a Future implementation that does implement FutureKind
+     * 
+     * @param newTry Future to widen to a FutureKind
+     * @return FutureKind encoding HKT info about Futures
+     */
+    public static <T> TryKind<T> widen(final Try<T> newTry) {
+        if (newTry instanceof TryKind)
+            return (TryKind<T>) newTry;
+        return new Box<>(
+                         newTry);
+    }
+    public static <T,X extends Throwable> TryKind<T> widen(final cyclops.control.Try<T,X> newTry) {
+
+        return new Box<>(FromCyclopsReact.toTry(
+                newTry));
+    }
+
+    /**
+     * Convert the raw Higher Kinded Type for FutureKind types into the FutureKind type definition class
+     * 
+     * @param future HKT encoded list into a FutureKind
+     * @return FutureKind
+     */
+    public static <T> TryKind<T> narrowK(final Higher<tryType, T> future) {
+       return (TryKind<T>)future;
+    }
+
+    /**
+     * Convert the HigherKindedType definition for a Future into
+     * 
+     * @param newTry Type Constructor to convert back into narrowed type
+     * @return Future from Higher Kinded Type
+     */
+    public static <T> Try<T> narrow(final Higher<tryType, T> newTry) {
+        if (newTry instanceof Try) {
+            return (Try)newTry;
+           
+        }
+        // this code should be unreachable due to HKT type checker
+        final Box<T> type = (Box<T>) newTry;
+        final Try<T> stage = type.narrow();
+        return stage;
+
+    }
+
+    @AllArgsConstructor(access = AccessLevel.PRIVATE)
+    static final class Box<T> implements TryKind<T> {
+
+        private final Try<T> boxed;
+
+        public Try<T> narrow() {
+            return boxed;
+        }
+        @Override
+        public T get() {
+            return boxed.get();
+        }
+
+        @Override
+        public Throwable getCause() {
+            return boxed.getCause();
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return boxed.isEmpty();
+        }
+
+        @Override
+        public String stringPrefix() {
+            return boxed.stringPrefix();
+        }
+
+        @Override
+        public boolean isFailure() {
+            return boxed.isFailure();
+        }
+
+        @Override
+        public boolean isSuccess() {
+            return boxed.isSuccess();
+        }
+    }
+
+    
+}
diff --git a/cyclops-vavr/src/main/java/cyclops/VavrConverters.java b/cyclops-vavr/src/main/java/cyclops/VavrConverters.java
index cfab2b5a..3b6ffa16 100644
--- a/cyclops-vavr/src/main/java/cyclops/VavrConverters.java
+++ b/cyclops-vavr/src/main/java/cyclops/VavrConverters.java
@@ -91,6 +91,8 @@ public static <T> List<T> List(CollectionX<T> vec){
                 });
     }
 
+
+
     public static <T> Vector<T> Vector(CollectionX<T> vec){
         return vec.unwrapNested(Vector.class,
                 ()-> {
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
index 883f145f..1cb6d21b 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
@@ -1,7 +1,13 @@
 package cyclops.companion.vavr;
 
 
+import com.aol.cyclops.vavr.hkt.LazyKind;
+import cyclops.VavrConverters;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.array;
 import com.aol.cyclops.vavr.hkt.ArrayKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -12,14 +18,23 @@
 import cyclops.monads.AnyM;
 
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.Lazy;
 import io.vavr.collection.Array;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
@@ -301,15 +316,79 @@ public static <T, R1, R> Array<R> forEach2(Array<? extends T> value1,
                     .map(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+    public static <T> Active<array,T> allTypeclasses(Array<T> array){
+        return Active.of(ArrayKind.widen(array), Instances.definitions());
+    }
+    public static <T,W2,R> Nested<array,W2,R> mapM(Array<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Array<Higher<W2, R>> e = array.map(fn);
+        ArrayKind<Higher<W2, R>> lk = ArrayKind.widen(e);
+        return Nested.of(lk, Arrays.Instances.definitions(), defs);
+    }
     /**
-     * Companion class for creating Type Class instances for working with Arrays
-     * @author johnmcclean
-     *
+     * Companion class for creating Type Class instances for working with Arrays*
      */
     @UtilityClass
     public static class Instances {
+        public static InstanceDefinitions<array> definitions() {
+            return new InstanceDefinitions<array>() {
+
+                @Override
+                public <T, R> Functor<array> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<array> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<array> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<array> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<array>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<array>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<array>> monadPlus(Monoid<Higher<array, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<array>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<array>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<array>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<array>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
 
-
+        }
         /**
          *
          * Transform a list, mulitplying every element by 2
@@ -486,11 +565,19 @@ public static <T> MonadPlus<array> monadPlus(){
          * @param m Monoid to use for combining Arrays
          * @return Type class for combining Arrays
          */
-        public static <T> MonadPlus<array> monadPlus(Monoid<ArrayKind<T>> m){
+        public static <T> MonadPlus<array> monadPlus(Monoid<Higher<array, T>> m){
             Monoid<Higher<array,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
+        public static Unfoldable<array> unfoldable(){
+            return new Unfoldable<array>() {
+                @Override
+                public <R, T> Higher<array, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return ArrayKind.widen(ReactiveSeq.unfold(b,fn).collect(Array.collector()));
 
+                }
+            };
+        }
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
index e537085b..afc15dff 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
@@ -1,8 +1,14 @@
 package cyclops.companion.vavr;
 
 
+import com.aol.cyclops.vavr.hkt.EitherKind;
+import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.Monoids;
+import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
+import cyclops.monads.Vavr;
 import cyclops.monads.VavrWitness;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
 import com.aol.cyclops2.types.Value;
@@ -13,7 +19,20 @@
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
+import cyclops.monads.VavrWitness.either;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
+import cyclops.typeclasses.comonad.ComonadByPure;
+import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
+import cyclops.typeclasses.functor.Functor;
+import cyclops.typeclasses.monad.*;
 import io.vavr.control.Either;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
@@ -30,8 +49,11 @@
  */
 @UtilityClass
 public class Eithers {
-   
-    public static <T> AnyMValue<VavrWitness.either,T> anyM(Either<?,T> either) {
+    public static <L, R> Either<L, R> xor(Xor<L, R> value) {
+        Xor<L, R> xor = (Xor) value.toXor();
+        return xor.visit(l -> Either.left(l), r -> Either.right(r));
+    }
+    public static <T> AnyMValue<either,T> anyM(Either<?,T> either) {
         return AnyM.ofValue(either, VavrWitness.either.INSTANCE);
     }
     /**
@@ -232,7 +254,7 @@ public static <L,T> Either<L,ListX<T>> sequencePresent(final CollectionX<Either<
      * @return  Either with a List of values
      */
     public static <L,T> Either<L,ReactiveSeq<T>> sequence(final Stream<Either<L,T>> opts) {
-        return AnyM.sequence(opts.map(Eithers::anyM), VavrWitness.either.INSTANCE)
+        return AnyM.sequence(opts.map(Eithers::anyM), either.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(VavrWitness::either);
 
@@ -420,5 +442,290 @@ public static <L,T> Either<L,T> narrow(final Either<L,? extends T> eitheral) {
     }
 
 
+    public static <L,R> Active<Higher<either,L>,R> allTypeclasses(Either<L,R> either){
+        return Active.of(EitherKind.widen(either), Eithers.Instances.definitions());
+    }
+    public static <L,R,W2,R2> Nested<Higher<either,L>,W2,R2> mapM(Either<L,R> either, Function<? super R,? extends Higher<W2,R2>> fn, InstanceDefinitions<W2> defs){
+        Either<L, Higher<W2, R2>> e = either.bimap(i -> i, i -> fn.apply(i));
+        EitherKind<L, Higher<W2, R2>> ek = EitherKind.widen(e);
+        return Nested.of(ek, Eithers.Instances.definitions(), defs);
+    }
+    public <L,R,W extends WitnessType<W>> XorT<W, L, R> liftM(Either<L,R> either, W witness) {
+        return XorT.of(witness.adapter().unit(ToCyclopsReact.xor(either)));
+    }
+
+    public static class Instances {
+
+        public static <L> InstanceDefinitions<Higher<either, L>> definitions(){
+            return new InstanceDefinitions<Higher<either, L>>() {
+                @Override
+                public <T, R> Functor<Higher<either, L>> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<Higher<either, L>> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<Higher<either, L>> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<Higher<either, L>> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<Higher<either, L>>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<Higher<either, L>>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<Higher<either, L>>> monadPlus(Monoid<Higher<Higher<either, L>, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<Higher<either, L>>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<Higher<either, L>>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<Higher<either, L>>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<Higher<either, L>>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
+        public static <L> Functor<Higher<either, L>> functor() {
+            return new Functor<Higher<either, L>>() {
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.bimap(i->i,r->fn.apply(r)));
+                }
+            };
+        }
+        public static <L> Pure<Higher<either, L>> unit() {
+            return new Pure<Higher<either, L>>() {
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return EitherKind.rightK(value);
+                }
+            };
+        }
+        public static <L> Applicative<Higher<either, L>> applicative() {
+            return new Applicative<Higher<either, L>>() {
+
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    Either<L,T> either = EitherKind.narrowK(apply);
+                    Either<L, ? extends Function<T, R>> eitherFn = EitherKind.narrowK(fn);
+                    return EitherKind.widen(Eithers.xor(ToCyclopsReact.xor(eitherFn).combine(ToCyclopsReact.xor(either),(a,b)->a.apply(b))));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Monad<Higher<either, L>> monad() {
+            return new Monad<Higher<either, L>>() {
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Traverse<Higher<either, L>> traverse() {
+            return new Traverse<Higher<either, L>>() {
+
+                @Override
+                public <C2, T, R> Higher<C2, Higher<Higher<either, L>, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> maybe = EitherKind.narrowK(ds);
+                    return maybe.fold(left->  applicative.unit(EitherKind.<L,R>leftK(left)),
+                            right->applicative.map(m->EitherKind.rightK(m), fn.apply(right)));
+                }
+
+                @Override
+                public <C2, T> Higher<C2, Higher<Higher<either, L>, T>> sequenceA(Applicative<C2> applicative, Higher<Higher<either, L>, Higher<C2, T>> ds) {
+                    return traverseA(applicative,Function.identity(),ds);
+                }
+
+
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Foldable<Higher<either, L>> foldable() {
+            return new Foldable<Higher<either, L>>() {
+
+
+                @Override
+                public <T> T foldRight(Monoid<T> monoid, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return ToCyclopsReact.xor(either).foldRight(monoid);
+                }
+
+                @Override
+                public <T> T foldLeft(Monoid<T> monoid, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return ToCyclopsReact.xor(either).foldLeft(monoid);
+                }
+            };
+        }
+        public static <L> MonadZero<Higher<either, L>> monadZero() {
+            return new MonadZero<Higher<either, L>>() {
+
+                @Override
+                public Higher<Higher<either, L>, ?> zero() {
+                    return EitherKind.leftK(null);
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> MonadPlus<Higher<either, L>> monadPlus() {
+            Monoid m = Monoids.firstPrimaryXor((Either)EitherKind.narrowK(Instances.<L>monadZero().zero()));
+
+            return monadPlus(m);
+        }
+        public static <L,T> MonadPlus<Higher<either, L>> monadPlus(Monoid<Higher<Higher<either, L>, T>> m) {
+            return new MonadPlus<Higher<either, L>>() {
+
+                @Override
+                public Monoid<Higher<Higher<either, L>, ?>> monoid() {
+                    return (Monoid)m;
+                }
+
+                @Override
+                public Higher<Higher<either, L>, ?> zero() {
+                    return Instances.<L>monadZero().zero();
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return EitherKind.widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
+                    return Instances.<L>applicative().ap(fn,apply);
+
+                }
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+        public static <L> Comonad<Higher<either, L>> comonad() {
+            return new ComonadByPure<Higher<either, L>>() {
+
+
+                @Override
+                public <T> T extract(Higher<Higher<either, L>, T> ds) {
+                    Either<L,T> either = EitherKind.narrowK(ds);
+                    return either.get();
+                }
+
+
+                @Override
+                public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
+                    return Instances.<L>functor().map(fn,ds);
+                }
+
+                @Override
+                public <T> Higher<Higher<either, L>, T> unit(T value) {
+                    return Instances.<L>unit().unit(value);
+                }
+            };
+        }
+    }
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
index 074e9cd3..ca7da6a4 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
@@ -1,10 +1,13 @@
 package cyclops.companion.vavr;
 
 
+import com.aol.cyclops.vavr.hkt.ArrayKind;
 import com.aol.cyclops2.react.Status;
 import com.aol.cyclops2.react.collectors.lazy.Blocker;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
+import cyclops.monads.Vavr;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.future;
 import com.aol.cyclops.vavr.hkt.FutureKind;
@@ -22,12 +25,17 @@
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.FutureT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.collection.Array;
 import io.vavr.concurrent.Future;
 
 import lombok.experimental.UtilityClass;
@@ -694,6 +702,15 @@ public static <T> Future<T> narrow(final Future<? extends T> futureal) {
         return (Future<T>) futureal;
     }
 
+    public static <T> Active<future,T> allTypeclasses(Future<T> future){
+        return Active.of(FutureKind.widen(future), Futures.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<future,W2,R> mapM(Future<T> future, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Future<Higher<W2, R>> e = future.map(fn);
+        FutureKind<Higher<W2, R>> lk = FutureKind.widen(e);
+        return Nested.of(lk, Futures.Instances.definitions(), defs);
+    }
+
     /**
      * Companion class for creating Type Class instances for working with Futures
      * @author johnmcclean
@@ -702,6 +719,65 @@ public static <T> Future<T> narrow(final Future<? extends T> futureal) {
     @UtilityClass
     public static class Instances {
 
+        public static  InstanceDefinitions<future> definitions() {
+            return new InstanceDefinitions<future>() {
+
+                @Override
+                public <T, R> Functor<future> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<future> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<future> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<future> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<future>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<future>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<future>> monadPlus(Monoid<Higher<future, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<future>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<future>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<future>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<future>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
 
         /**
          *
@@ -881,7 +957,7 @@ public static <T> MonadPlus<future> monadPlus(){
          * @param m Monoid to use for combining Futures
          * @return Type class for combining Futures
          */
-        public static <T> MonadPlus<future> monadPlus(Monoid<FutureKind<T>> m){
+        public static <T> MonadPlus<future> monadPlus(Monoid<Higher<future, T>> m){
             Monoid<Higher<future,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
index 2b2ff195..245ea127 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
@@ -1,6 +1,8 @@
 package cyclops.companion.vavr;
 
 
+import com.aol.cyclops.vavr.hkt.EitherKind;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import com.aol.cyclops.vavr.hkt.LazyKind;
@@ -19,14 +21,20 @@
 import cyclops.monads.Witness;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.EvalT;
+import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
 import io.vavr.Lazy;
+import io.vavr.control.Either;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
@@ -427,10 +435,77 @@ public static <T1, T2, R> Lazy<R> zip(final Publisher<? extends T2> p, final Laz
     public static <T> Lazy<T> narrow(final Lazy<? extends T> futureal) {
         return (Lazy<T>) futureal;
     }
+    public static <T> Active<lazy,T> allTypeclasses(Lazy<T> lazy){
+        return Active.of(LazyKind.widen(lazy), Lazys.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<lazy,W2,R> mapM(Lazy<T> lazy, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Lazy<Higher<W2, R>> e = lazy.map(fn);
+        LazyKind<Higher<W2, R>> lk = LazyKind.widen(e);
+        return Nested.of(lk, Lazys.Instances.definitions(), defs);
+    }
+
     @UtilityClass
     public static class Instances {
 
-
+        public static  InstanceDefinitions<lazy> definitions() {
+            return new InstanceDefinitions<lazy>() {
+
+                @Override
+                public <T, R> Functor<lazy> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<lazy> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<lazy> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<lazy> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<lazy>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<lazy>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<lazy>> monadPlus(Monoid<Higher<lazy, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<lazy>> traverse() {
+                    return null;
+                }
+
+                @Override
+                public <T> Maybe<Foldable<lazy>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<lazy>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<lazy>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        };
         /**
          *
          * Transform a lazy, mulitplying every element by 2
@@ -608,7 +683,7 @@ public static <T> MonadPlus<lazy> monadPlus(){
          * @param m Monoid to use for combining Lazys
          * @return Type class for combining Lazys
          */
-        public static <T> MonadPlus<lazy> monadPlus(Monoid<LazyKind<T>> m){
+        public static <T> MonadPlus<lazy> monadPlus(Monoid<Higher<lazy,T>> m){
             Monoid<Higher<lazy,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
index c89240ba..8a4d2cde 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
@@ -1,6 +1,10 @@
 package cyclops.companion.vavr;
 
 
+import com.aol.cyclops.vavr.hkt.TryKind;
+import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.Monoids;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
@@ -13,11 +17,23 @@
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
+import cyclops.monads.VavrWitness.tryType;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
+import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
+import cyclops.typeclasses.functor.Functor;
+import cyclops.typeclasses.instances.General;
+import cyclops.typeclasses.monad.*;
 import io.vavr.control.Try;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
+import java.util.NoSuchElementException;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
@@ -31,7 +47,7 @@
 @UtilityClass
 public class Trys {
 
-    public static <T> AnyMValue<VavrWitness.tryType,T> anyM(Try<T> tryType) {
+    public static <T> AnyMValue<tryType,T> anyM(Try<T> tryType) {
         return AnyM.ofValue(tryType, VavrWitness.tryType.INSTANCE);
     }
     /**
@@ -363,7 +379,7 @@ public static <T> Try<ListX<T>> sequencePresent(final CollectionX<Try<T>> opts)
      * @return  Try with a List of values
      */
     public static <T> Try<ReactiveSeq<T>> sequence(final Stream<Try<T>> opts) {
-        return AnyM.sequence(opts.map(Trys::anyM), VavrWitness.tryType.INSTANCE)
+        return AnyM.sequence(opts.map(Trys::anyM), tryType.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(VavrWitness::tryType);
 
@@ -550,6 +566,321 @@ public static <T> Try<T> narrow(final Try<? extends T> tryTypeal) {
         return (Try<T>) tryTypeal;
     }
 
-    
+    public static <T> Active<tryType,T> allTypeclasses(Try<T> tryType){
+        return Active.of(TryKind.widen(tryType), Trys.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<tryType,W2,R> mapM(Try<T> tryType, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Try<Higher<W2, R>> e = tryType.map(fn);
+        TryKind<Higher<W2, R>> lk = TryKind.widen(e);
+        return Nested.of(lk, Trys.Instances.definitions(), defs);
+    }
+
+    /**
+     * Companion class for creating Type Class instances for working with Trys
+     * @author johnmcclean
+     *
+     */
+    @UtilityClass
+    public static class Instances {
+
+        public static InstanceDefinitions<tryType> definitions() {
+            return new InstanceDefinitions<tryType>() {
+
+                @Override
+                public <T, R> Functor<tryType> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<tryType> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<tryType> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<tryType> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<tryType>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<tryType>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<tryType>> monadPlus(Monoid<Higher<tryType, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<tryType>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<tryType>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<tryType>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<tryType>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
+
+        /**
+         *
+         * Transform a Try, mulitplying every element by 2
+         *
+         * <pre>
+         * {@code
+         *  TryKind<Integer> tryType = Trys.functor().map(i->i*2, TryKind.widen(Try.successful(1));
+         *
+         *  //[2]
+         *
+         *
+         * }
+         * </pre>
+         *
+         * An example fluent api working with Trys
+         * <pre>
+         * {@code
+         *   TryKind<Integer> ft = Trys.unit()
+        .unit("hello")
+        .then(h->Trys.functor().map((String v) ->v.length(), h))
+        .convert(TryKind::narrowK);
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A functor for Trys
+         */
+        public static <T,R>Functor<tryType> functor(){
+            BiFunction<TryKind<T>,Function<? super T, ? extends R>,TryKind<R>> map = Instances::map;
+            return General.functor(map);
+        }
+        /**
+         * <pre>
+         * {@code
+         * TryKind<String> ft = Trys.unit()
+        .unit("hello")
+        .convert(TryKind::narrowK);
+
+        //Arrays.asTry("hello"))
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A factory for Trys
+         */
+        public static <T> Pure<tryType> unit(){
+            return General.<tryType,T>unit(Instances::of);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         * import static com.aol.cyclops.hkt.jdk.TryKind.widen;
+         * import static com.aol.cyclops.util.function.Lambda.l1;
+         *
+        Trys.applicative()
+        .ap(widen(Try.successful(l1(this::multiplyByTwo))),widen(asTry(1,2,3)));
+         *
+         * //[2,4,6]
+         * }
+         * </pre>
+         *
+         *
+         * Example fluent API
+         * <pre>
+         * {@code
+         * TryKind<Function<Integer,Integer>> ftFn =Trys.unit()
+         *                                                  .unit(Lambda.l1((Integer i) ->i*2))
+         *                                                  .convert(TryKind::narrowK);
+
+        TryKind<Integer> ft = Trys.unit()
+        .unit("hello")
+        .then(h->Trys.functor().map((String v) ->v.length(), h))
+        .then(h->Trys.applicative().ap(ftFn, h))
+        .convert(TryKind::narrowK);
+
+        //Arrays.asTry("hello".length()*2))
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A zipper for Trys
+         */
+        public static <T,R> Applicative<tryType> applicative(){
+            BiFunction<TryKind< Function<T, R>>,TryKind<T>,TryKind<R>> ap = Instances::ap;
+            return General.applicative(functor(), unit(), ap);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         * import static com.aol.cyclops.hkt.jdk.TryKind.widen;
+         * TryKind<Integer> ft  = Trys.monad()
+        .flatMap(i->widen(Try.successful(i), widen(Try.successful(3))
+        .convert(TryKind::narrowK);
+         * }
+         * </pre>
+         *
+         * Example fluent API
+         * <pre>
+         * {@code
+         *    TryKind<Integer> ft = Trys.unit()
+        .unit("hello")
+        .then(h->Trys.monad().flatMap((String v) ->Trys.unit().unit(v.length()), h))
+        .convert(TryKind::narrowK);
+
+        //Arrays.asTry("hello".length())
+         *
+         * }
+         * </pre>
+         *
+         * @return Type class with monad functions for Trys
+         */
+        public static <T,R> Monad<tryType> monad(){
+
+            BiFunction<Higher<tryType,T>,Function<? super T, ? extends Higher<tryType,R>>,Higher<tryType,R>> flatMap = Instances::flatMap;
+            return General.monad(applicative(), flatMap);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         *  TryKind<String> ft = Trys.unit()
+        .unit("hello")
+        .then(h->Trys.monadZero().filter((String t)->t.startsWith("he"), h))
+        .convert(TryKind::narrowK);
+
+        //Arrays.asTry("hello"));
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A filterable monad (with default value)
+         */
+        public static <T,R> MonadZero<tryType> monadZero(){
+
+            return General.monadZero(monad(), TryKind.failed(new NoSuchElementException()));
+        }
+        /**
+         * <pre>
+         * {@code
+         *  TryKind<Integer> ft = Trys.<Integer>monadPlus()
+        .plus(TryKind.widen(Arrays.asTry()), TryKind.widen(Try.successful((10)))
+        .convert(TryKind::narrowK);
+        //Try(10)
+         *
+         * }
+         * </pre>
+         * @return Type class for combining Trys by concatenation
+         */
+        public static <T> MonadPlus<tryType> monadPlus(){
+            Monoid<cyclops.control.Try<T,Throwable>> mn = Monoids.firstTrySuccess(new NoSuchElementException());
+            Monoid<TryKind<T>> m = Monoid.of(TryKind.widen(mn.zero()), (f, g)-> TryKind.widen(
+                    mn.apply(ToCyclopsReact.toTry(f), ToCyclopsReact.toTry(g))));
+
+            Monoid<Higher<tryType,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         *  Monoid<TryKind<Integer>> m = Monoid.of(TryKind.widen(Try.failed(e), (a,b)->a.isEmpty() ? b : a);
+        TryKind<Integer> ft = Trys.<Integer>monadPlus(m)
+        .plus(TryKind.widen(Try.successful(5), TryKind.widen(Try.successful(10))
+        .convert(TryKind::narrowK);
+        //Try(5)
+         *
+         * }
+         * </pre>
+         *
+         * @param m Monoid to use for combining Trys
+         * @return Type class for combining Trys
+         */
+        public static <T> MonadPlus<tryType> monadPlus(Monoid<Higher<tryType, T>> m){
+            Monoid<Higher<tryType,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+
+        /**
+         * @return Type class for traversables with traverse / sequence operations
+         */
+        public static <C2,T> Traverse<tryType> traverse(){
+
+            return General.traverseByTraverse(applicative(), Instances::traverseA);
+        }
+
+        /**
+         *
+         * <pre>
+         * {@code
+         * int sum  = Trys.foldable()
+        .foldLeft(0, (a,b)->a+b, TryKind.widen(Try.successful(4));
+
+        //4
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return Type class for folding / reduction operations
+         */
+        public static <T> Foldable<tryType> foldable(){
+            BiFunction<Monoid<T>,Higher<tryType,T>,T> foldRightFn =  (m, l)-> m.apply(m.zero(), TryKind.narrow(l).get());
+            BiFunction<Monoid<T>,Higher<tryType,T>,T> foldLeftFn = (m, l)->  m.apply(m.zero(), TryKind.narrow(l).get());
+            return General.foldable(foldRightFn, foldLeftFn);
+        }
+        public static <T> Comonad<tryType> comonad(){
+            Function<? super Higher<tryType, T>, ? extends T> extractFn = maybe -> maybe.convert(TryKind::narrow).get();
+            return General.comonad(functor(), unit(), extractFn);
+        }
+
+        private <T> TryKind<T> of(T value){
+            return TryKind.widen(Try.success(value));
+        }
+        private static <T,R> TryKind<R> ap(TryKind<Function< T, R>> lt, TryKind<T> list){
+            return TryKind.widen(ToCyclopsReact.toTry(lt).combine(ToCyclopsReact.toTry(list), (a, b)->a.apply(b)));
+
+        }
+        private static <T,R> Higher<tryType,R> flatMap(Higher<tryType,T> lt, Function<? super T, ? extends  Higher<tryType,R>> fn){
+            return TryKind.widen(TryKind.narrow(lt).flatMap(fn.andThen(TryKind::narrowK)));
+        }
+        private static <T,R> TryKind<R> map(TryKind<T> lt, Function<? super T, ? extends R> fn){
+            return TryKind.widen(lt.map(fn));
+        }
+
+
+        private static <C2,T,R> Higher<C2, Higher<tryType, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn,
+                                                                         Higher<tryType, T> ds){
+            Try<T> tryType = TryKind.narrow(ds);
+            return applicative.map(TryKind::successful, fn.apply(tryType.get()));
+        }
+
+    }
+
 
 }

From ff0cfcd3ea271d8eea01544f77545e33d7133f27 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Tue, 4 Jul 2017 22:24:34 +0100
Subject: [PATCH 04/30] fix compile errors

---
 cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java | 4 ++++
 .../src/main/java/cyclops/companion/vavr/Futures.java         | 4 ++++
 cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java  | 4 ++++
 .../cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java    | 2 +-
 .../cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java   | 2 +-
 .../vavr/hkt/typeclesses/instances/LazyInstancesTest.java     | 2 +-
 6 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
index 1cb6d21b..e300c99a 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
@@ -569,6 +569,10 @@ public static <T> MonadPlus<array> monadPlus(Monoid<Higher<array, T>> m){
             Monoid<Higher<array,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
+        public static <T> MonadPlus<array> monadPlusK(Monoid<ArrayKind<T>> m){
+            Monoid<Higher<array,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
         public static Unfoldable<array> unfoldable(){
             return new Unfoldable<array>() {
                 @Override
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
index ca7da6a4..1ff44830 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
@@ -961,6 +961,10 @@ public static <T> MonadPlus<future> monadPlus(Monoid<Higher<future, T>> m){
             Monoid<Higher<future,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
+        public static <T> MonadPlus<future> monadPlusK(Monoid<FutureKind<T>> m){
+            Monoid<Higher<future,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
index 245ea127..35bff5fd 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
@@ -688,6 +688,10 @@ public static <T> MonadPlus<lazy> monadPlus(Monoid<Higher<lazy,T>> m){
             return General.monadPlus(monadZero(),m2);
         }
 
+        public static <T> MonadPlus<lazy> monadPlusK(Monoid<LazyKind<T>> m){
+            return monadPlus((Monoid)m);
+        }
+
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java
index 41b7bc78..a75ece68 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/ArraysTest.java
@@ -108,7 +108,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<ArrayKind<Integer>> m = Monoid.of(ArrayKind.widen(Array.empty()), (a, b)->a.isEmpty() ? b : a);
-        ArrayKind<Integer> list = Arrays.Instances.<Integer>monadPlus(m)
+        ArrayKind<Integer> list = Arrays.Instances.<Integer>monadPlusK(m)
                                       .plus(ArrayKind.widen(Array.of(5)), ArrayKind.widen(Array.of(10)))
                                       .convert(ArrayKind::narrowK);
         assertThat(list,equalTo(Array.of(5)));
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java
index 8c7870bf..be3b21e9 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/FuturesTest.java
@@ -113,7 +113,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<FutureKind<Integer>> m = Monoid.of(FutureKind.widen(cyclops.async.Future.future()), (a, b)->a.isCompleted() ? b : a);
-        FutureKind<Integer> opt = Futures.Instances.<Integer>monadPlus(m)
+        FutureKind<Integer> opt = Futures.Instances.<Integer>monadPlusK(m)
                                       .plus(FutureKind.widen(Future.successful(5)), FutureKind.widen(Future.successful(10)))
                                       .convert(FutureKind::narrowK);
         assertThat(opt.get(),equalTo(Future.successful(10).get()));
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java
index 789f39e9..32cdf9e4 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/LazyInstancesTest.java
@@ -113,7 +113,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<LazyKind<Integer>> m = Monoid.of(LazyKind.widen(Lazy.of(()->null)), (a, b)->a.get()==null ? b : a);
-        LazyKind<Integer> opt = Instances.<Integer>monadPlus(m)
+        LazyKind<Integer> opt = Instances.<Integer>monadPlusK(m)
                                       .plus(LazyKind.widen(Lazy.of(()->5)), LazyKind.widen(Lazy.of(()->10)))
                                       .convert(LazyKind::narrowK);
         assertThat(opt,equalTo(Lazy.of(()->5)));

From bc799c3e92d2b6e44b94cf20bf52e25f73123e1d Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Tue, 4 Jul 2017 23:25:35 +0100
Subject: [PATCH 05/30] Add support for Vavr sets

---
 .../com/aol/cyclops/vavr/hkt/ArrayKind.java   |   1 +
 .../com/aol/cyclops/vavr/hkt/ListKind.java    | 208 +++---
 .../com/aol/cyclops/vavr/hkt/SetKind.java     | 181 +++++
 .../com/aol/cyclops/vavr/hkt/VectorKind.java  |  22 +
 .../cyclops/collections/vavr/VavrVectorX.java |   5 +
 .../java/cyclops/companion/vavr/Lists.java    |  97 ++-
 .../java/cyclops/companion/vavr/Sets.java     | 644 ++++++++++++++++++
 .../java/cyclops/companion/vavr/Vectors.java  |  95 ++-
 .../main/java/cyclops/monads/VavrWitness.java |  10 +-
 9 files changed, 1165 insertions(+), 98 deletions(-)
 create mode 100644 cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
 create mode 100644 cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java

diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
index 83f21242..ac29cdda 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
@@ -33,6 +33,7 @@ public  class ArrayKind<T> implements Higher<array, T>{
     public Active<array,T> allTypeclasses(){
         return Active.of(this, Arrays.Instances.definitions());
     }
+
     public <W2,R> Nested<array,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Array<Higher<W2, R>> e = map(fn);
         ArrayKind<Higher<W2, R>> lk = ArrayKind.widen(e);
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
index e4e1e2ca..45a6cca7 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
@@ -1,10 +1,21 @@
 package com.aol.cyclops.vavr.hkt;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.collections.vavr.VavrListX;
+import cyclops.companion.vavr.Lists;
+import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.list;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.ListT;
+import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.vavr.collection.List;
+import io.vavr.concurrent.Future;
+import io.vavr.control.Either;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
@@ -14,6 +25,8 @@
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 
+import java.util.function.Function;
+
 /**
  * Simulates Higher Kinded Types for Vavr List's
  * 
@@ -24,9 +37,22 @@
  * @param <T> Data type stored within the List
  */
 
-@AllArgsConstructor(access = AccessLevel.PRIVATE)
-public final class ListKind<T> implements Higher<list, T>, Publisher<T>, List<T> {
 
+public interface ListKind<T> extends Higher<list, T>, Publisher<T>, List<T> {
+
+    default Active<list,T> allTypeclasses(){
+        return Active.of(this, Lists.Instances.definitions());
+    }
+
+    default <W2,R> Nested<list,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Lists.mapM(this,fn,defs);
+    }
+    default <R> ListKind<R> fold(Function<? super List<? super T>,? extends List<R>> op){
+        return widen(op.apply(this));
+    }
+    default <W extends WitnessType<W>> ListT<W, T> liftM(W witness) {
+        return ListT.of(witness.adapter().unit(VavrListX.from(this)));
+    }
     /**
      * Construct a HKT encoded completed List
      * 
@@ -59,7 +85,7 @@ public static <T> ListKind<T> empty() {
      */
     public static <T> ListKind<T> widen(final List<T> completableList) {
 
-        return new ListKind<>(
+        return new Box<>(
                                 completableList);
     }
 
@@ -78,7 +104,7 @@ public static <C2, T> Higher<C2, Higher<list, T>> widen2(Higher<C2, ListKind<T>>
 
     public static <T> ListKind<T> widen(final Publisher<T> completableList) {
 
-        return new ListKind<>(
+        return new Box<>(
                                 List.ofAll((Iterable<T>)ReactiveSeq.fromPublisher(completableList)));
     }
 
@@ -103,92 +129,92 @@ public static <T> List<T> narrow(final Higher<list, T> list) {
         return ((ListKind<T>) list).narrow();
 
     }
-
-    private final List<T> boxed;
-
-    public ReactiveSeq<T> toReactiveSeq(){
-        return ReactiveSeq.fromIterable(boxed);
-    }
-    /**
-     * @return wrapped List
-     */
-    public List<T> narrow() {
-        return boxed;
-    }
-
-    @Override
-    public void subscribe(Subscriber<? super T> s) {
-        ReactiveSeq.fromIterable(boxed)
-                   .subscribe(s);
-
-    }
-
-   
-
-    /**
-     * @return
-     * @see io.vavr.collection.Traversable#head()
-     */
-    public T head() {
-        return boxed.head();
-    }
-    
-
-    /**
-     * @param o
-     * @return
-     * @see io.vavr.Value#equals(java.lang.Object)
-     */
-    public boolean equals(Object o) {
-        return boxed.equals(o);
-    }
-
-    
-
-    /**
-     * @return
-     * @see io.vavr.Value#hashCode()
-     */
-    public int hashCode() {
-        return boxed.hashCode();
-    }
-
-   
-    /**
-     * @return
-     * @see io.vavr.Value#toString()
-     */
-    public String toString() {
-        return boxed.toString();
-    }
-
-   
-    
-
-    /**
-     * @return
-     * @see io.vavr.collection.List#tail()
-     */
-    public List<T> tail() {
-        return boxed.tail();
-    }
-
-    /**
-     * @return
-     * @see io.vavr.collection.Traversable#isEmpty()
-     */
-    public boolean isEmpty() {
-        return boxed.isEmpty();
-    }
-
-    /**
-     * @return
-     * @see io.vavr.collection.List#length()
-     */
-    public int length() {
-        return boxed.length();
+    public List<T> narrow();
+    public ReactiveSeq<T> toReactiveSeq();
+
+    @AllArgsConstructor(access = AccessLevel.PRIVATE)
+    static final class Box<T> implements ListKind<T> {
+
+        private final List<T> boxed;
+        public ReactiveSeq<T> toReactiveSeq(){
+            return ReactiveSeq.fromIterable(boxed);
+        }
+
+        /**
+         * @return wrapped List
+         */
+        public List<T> narrow() {
+            return boxed;
+        }
+
+        @Override
+        public void subscribe(Subscriber<? super T> s) {
+            ReactiveSeq.fromIterable(boxed)
+                    .subscribe(s);
+
+        }
+        /**
+         * @return
+         * @see io.vavr.collection.Traversable#head()
+         */
+        public T head() {
+            return boxed.head();
+        }
+
+
+        /**
+         * @param o
+         * @return
+         * @see io.vavr.Value#equals(java.lang.Object)
+         */
+        public boolean equals(Object o) {
+            return boxed.equals(o);
+        }
+
+
+
+        /**
+         * @return
+         * @see io.vavr.Value#hashCode()
+         */
+        public int hashCode() {
+            return boxed.hashCode();
+        }
+
+
+        /**
+         * @return
+         * @see io.vavr.Value#toString()
+         */
+        public String toString() {
+            return boxed.toString();
+        }
+
+
+
+
+        /**
+         * @return
+         * @see io.vavr.collection.List#tail()
+         */
+        public List<T> tail() {
+            return boxed.tail();
+        }
+
+        /**
+         * @return
+         * @see io.vavr.collection.Traversable#isEmpty()
+         */
+        public boolean isEmpty() {
+            return boxed.isEmpty();
+        }
+
+        /**
+         * @return
+         * @see io.vavr.collection.List#length()
+         */
+        public int length() {
+            return boxed.length();
+        }
     }
-
-    
-
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
new file mode 100644
index 00000000..a802fc3d
--- /dev/null
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
@@ -0,0 +1,181 @@
+package com.aol.cyclops.vavr.hkt;
+
+import com.aol.cyclops2.hkt.Higher;
+import cyclops.collections.vavr.VavrSetX;
+import cyclops.companion.vavr.Sets;
+import cyclops.monads.VavrWitness.set;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.SetT;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import io.vavr.collection.HashSet;
+import io.vavr.collection.Set;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.experimental.Delegate;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import java.util.function.Function;
+
+/**
+ * Simulates Higher Kinded Types for Vavr Set's
+ * 
+ * SetKind is a Set and a Higher Kinded Type (SetKind.µ,T)
+ * 
+ * @author johnmcclean
+ *
+ * @param <T> Data type stored within the Set
+ */
+
+
+public interface SetKind<T> extends Higher<set, T>, Publisher<T>, Set<T> {
+
+    default Active<set,T> allTypeclasses(){
+        return Active.of(this, Sets.Instances.definitions());
+    }
+
+    default <W2,R> Nested<set,W2,R> mapM(Function<? super T, ? extends Higher<W2, R>> fn, InstanceDefinitions<W2> defs){
+        return Sets.mapM(this,fn,defs);
+    }
+    default <R> SetKind<R> fold(Function<? super Set<? super T>, ? extends Set<R>> op){
+        return widen(op.apply(this));
+    }
+
+    /**
+     * Construct a HKT encoded completed Set
+     * 
+     * @param value To encode inside a HKT encoded Set
+     * @return Completed HKT encoded FSet
+     */
+    public static <T> SetKind<T> just(T value) {
+
+        return widen(HashSet.of(value));
+    }
+
+    public static <T> SetKind<T> just(T... values) {
+
+        return widen(HashSet.of(values));
+    }
+
+    public static <T> SetKind<T> empty() {
+        return widen(HashSet.empty());
+    }
+
+    /**
+     * Convert a Set to a simulated HigherKindedType that captures Set nature
+     * and Set element data type separately. Recover via @see SetKind#narrow
+     * 
+     * If the supplied Set implements SetKind it is returned already, otherwise it
+     * is wrapped into a Set implementation that does implement SetKind
+     * 
+     * @param completableSet Set to widen to a SetKind
+     * @return SetKind encoding HKT info about Sets
+     */
+    public static <T> SetKind<T> widen(final Set<T> completableSet) {
+
+        return new Box<>(
+                                completableSet);
+    }
+
+    /**
+     * Widen a SetKind nested inside another HKT encoded type
+     * 
+     * @param flux HTK encoded type containing  a Set to widen
+     * @return HKT encoded type with a widened Set
+     */
+    public static <C2, T> Higher<C2, Higher<set, T>> widen2(Higher<C2, SetKind<T>> flux) {
+        // a functor could be used (if C2 is a functor / one exists for C2 type)
+        // instead of casting
+        // cast seems safer as Higher<set,T> must be a SetKind
+        return (Higher) flux;
+    }
+
+    public static <T> SetKind<T> widen(final Publisher<T> completableSet) {
+
+        return new Box<>(
+                                HashSet.ofAll((Iterable<T>)ReactiveSeq.fromPublisher(completableSet)));
+    }
+
+    /**
+     * Convert the raw Higher Kinded Type for SetKind types into the SetKind type definition class
+     * 
+     * @param future HKT encoded set into a SetKind
+     * @return SetKind
+     */
+    public static <T> SetKind<T> narrowK(final Higher<set, T> future) {
+        return (SetKind<T>) future;
+    }
+
+    /**
+     * Convert the HigherKindedType definition for a Set into
+     * 
+     * @param set Type Constructor to convert back into narrowed type
+     * @return Set from Higher Kinded Type
+     */
+    public static <T> Set<T> narrow(final Higher<set, T> set) {
+
+        return ((SetKind<T>) set).narrow();
+
+    }
+    public Set<T> narrow();
+    public ReactiveSeq<T> toReactiveSeq();
+
+    @AllArgsConstructor(access = AccessLevel.PRIVATE)
+    static final class Box<T> implements SetKind<T> {
+
+        @Delegate
+        private final Set<T> boxed;
+        public ReactiveSeq<T> toReactiveSeq(){
+            return ReactiveSeq.fromIterable(boxed);
+        }
+
+        /**
+         * @return wrapped Set
+         */
+        public Set<T> narrow() {
+            return boxed;
+        }
+
+        @Override
+        public void subscribe(Subscriber<? super T> s) {
+            ReactiveSeq.fromIterable(boxed)
+                    .subscribe(s);
+
+        }
+
+
+        /**
+         * @param o
+         * @return
+         * @see io.vavr.Value#equals(Object)
+         */
+        public boolean equals(Object o) {
+            return boxed.equals(o);
+        }
+
+
+
+        /**
+         * @return
+         * @see io.vavr.Value#hashCode()
+         */
+        public int hashCode() {
+            return boxed.hashCode();
+        }
+
+
+        /**
+         * @return
+         * @see io.vavr.Value#toString()
+         */
+        public String toString() {
+            return boxed.toString();
+        }
+
+
+
+    }
+}
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
index e4cd3df0..495d8b69 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
@@ -19,8 +19,17 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.collections.vavr.VavrListX;
+import cyclops.collections.vavr.VavrVectorX;
+import cyclops.companion.vavr.Lists;
+import cyclops.companion.vavr.Vectors;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.vector;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.ListT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.vavr.collection.Vector;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -38,6 +47,19 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class VectorKind<T> implements Higher<vector, T>{
 
+    public Active<vector,T> allTypeclasses(){
+        return Active.of(this, Vectors.Instances.definitions());
+    }
+
+    public <W2,R> Nested<vector,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Vectors.mapM(boxed,fn,defs);
+    }
+    public <R> VectorKind<R> fold(Function<? super Vector<? super T>,? extends Vector<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public <W extends WitnessType<W>> ListT<W, T> liftM(W witness) {
+        return ListT.of(witness.adapter().unit(VavrVectorX.from(boxed)));
+    }
     public static <T> VectorKind<T> of(T element) {
         return  widen(Vector.of(element));
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrVectorX.java b/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrVectorX.java
index e65c3346..84b910e4 100644
--- a/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrVectorX.java
+++ b/cyclops-vavr/src/main/java/cyclops/collections/vavr/VavrVectorX.java
@@ -9,12 +9,14 @@
 import java.util.stream.Stream;
 
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
+import com.aol.cyclops2.data.collections.extensions.lazy.immutable.LazyLinkedListX;
 import com.aol.cyclops2.data.collections.extensions.lazy.immutable.LazyPVectorX;
 import com.aol.cyclops2.types.Unwrapable;
 import com.aol.cyclops2.types.foldable.Evaluation;
 import cyclops.collections.immutable.VectorX;
 import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
+import io.vavr.collection.List;
 import org.jooq.lambda.tuple.Tuple2;
 import org.pcollections.PVector;
 
@@ -156,6 +158,9 @@ public static <T> LazyPVectorX<T> ofAll(Vector<T> t){
     public static <T> LazyPVectorX<T> PVector(Vector<T> q) {
         return fromPVector(new VavrVectorX<T>(q), toPVector());
     }
+    public static <T> LazyPVectorX<T> from(Vector<T> q) {
+        return PVector(q);
+    }
     @SafeVarargs
     public static <T> LazyPVectorX<T> PVector(T... elements){
         return fromPVector(of(elements),toPVector());
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
index 3692eb24..c55f5380 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
@@ -1,5 +1,8 @@
 package cyclops.companion.vavr;
 
+import com.aol.cyclops.vavr.hkt.ArrayKind;
+import cyclops.control.Maybe;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.list;
 import cyclops.collections.vavr.VavrListX;
 import com.aol.cyclops.vavr.hkt.ListKind;
@@ -12,14 +15,22 @@
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.ListT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.collection.Array;
 import io.vavr.collection.List;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.*;
 
 
@@ -299,15 +310,81 @@ public static <T, R1, R> List<R> forEach2(List<? extends T> value1,
                     .map(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+
+    public static <T> Active<list,T> allTypeclasses(List<T> array){
+        return Active.of(ListKind.widen(array), Lists.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<list,W2,R> mapM(List<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        List<Higher<W2, R>> e = array.map(fn);
+        ListKind<Higher<W2, R>> lk = ListKind.widen(e);
+        return Nested.of(lk, Lists.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Lists
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<list> definitions() {
+            return new InstanceDefinitions<list>() {
+
+                @Override
+                public <T, R> Functor<list> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<list> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<list> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<list> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<list>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<list>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<list>> monadPlus(Monoid<Higher<list, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<list>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<list>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<list>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<list>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
         /**
          *
          * Transform a list, mulitplying every element by 2
@@ -484,7 +561,11 @@ public static <T> MonadPlus<list> monadPlus(){
          * @param m Monoid to use for combining Lists
          * @return Type class for combining Lists
          */
-        public static <T> MonadPlus<list> monadPlus(Monoid<ListKind<T>> m){
+        public static <T> MonadPlus<list> monadPlus(Monoid<Higher<list,T>> m){
+            Monoid<Higher<list,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<list> monadPlusK(Monoid<ListKind<T>> m){
             Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -551,7 +632,17 @@ private static <T,R> ListKind<R> map(ListKind<T> lt, Function<? super T, ? exten
         private static <T> ListKind<T> filter(Higher<list,T> lt, Predicate<? super T> fn){
             return ListKind.widen(ListKind.narrow(lt).filter(fn));
         }
+        public static Unfoldable<list> unfoldable(){
+            return new Unfoldable<list>() {
+                @Override
+                public <R, T> Higher<list, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return ListKind.widen(ReactiveSeq.unfold(b,fn).collect(List.collector()));
+
+                }
+            };
+        }
     }
 
 
+
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
new file mode 100644
index 00000000..31e64bc7
--- /dev/null
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
@@ -0,0 +1,644 @@
+package cyclops.companion.vavr;
+
+import com.aol.cyclops.vavr.hkt.SetKind;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+
+import cyclops.control.Maybe;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.AnyM;
+import cyclops.monads.VavrWitness.set;
+import cyclops.monads.WitnessType;
+
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
+import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
+import cyclops.typeclasses.functor.Functor;
+import cyclops.typeclasses.instances.General;
+import cyclops.typeclasses.monad.*;
+import io.vavr.collection.HashSet;
+import io.vavr.collection.Set;
+import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
+
+import java.util.Optional;
+import java.util.function.*;
+
+
+public class Sets {
+
+    public static <T> AnyMSeq<set,T> anyM(Set<T> option) {
+        return AnyM.ofSeq(option, set.INSTANCE);
+    }
+    /**
+     * Perform a For Comprehension over a Set, accepting 3 generating functions.
+     * This results in a four level nested internal iteration over the provided Publishers.
+     *
+     *  <pre>
+     * {@code
+     *
+     *   import static cyclops.Sets.forEach4;
+     *
+    forEach4(IntSet.range(1,10).boxed(),
+    a-> Set.iterate(a,i->i+1).limit(10),
+    (a,b) -> Set.<Integer>of(a+b),
+    (a,b,c) -> Set.<Integer>just(a+b+c),
+    Tuple::tuple)
+     *
+     * }
+     * </pre>
+     *
+     * @param value1 top level Set
+     * @param value2 Nested Set
+     * @param value3 Nested Set
+     * @param value4 Nested Set
+     * @param yieldingFunction  Generates a result per combination
+     * @return Set with an element per combination of nested publishers generated by the yielding function
+     */
+    public static <T1, T2, T3, R1, R2, R3, R> Set<R> forEach4(Set<? extends T1> value1,
+                                                               Function<? super T1, ? extends Set<R1>> value2,
+                                                               BiFunction<? super T1, ? super R1, ? extends Set<R2>> value3,
+                                                               Fn3<? super T1, ? super R1, ? super R2, ? extends Set<R3>> value4,
+                                                               Fn4<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
+
+
+        return value1.flatMap(in -> {
+
+            Set<R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Set<R2> b = value3.apply(in,ina);
+                return b.flatMap(inb -> {
+                    Set<R3> c = value4.apply(in,ina,inb);
+                    return c.map(in2 -> yieldingFunction.apply(in, ina, inb, in2));
+                });
+
+            });
+
+        });
+
+    }
+
+    /**
+     * Perform a For Comprehension over a Set, accepting 3 generating function.
+     * This results in a four level nested internal iteration over the provided Publishers.
+     * <pre>
+     * {@code
+     *
+     *  import static com.aol.cyclops2.reactor.Setes.forEach4;
+     *
+     *  forEach4(IntSet.range(1,10).boxed(),
+    a-> Set.iterate(a,i->i+1).limit(10),
+    (a,b) -> Set.<Integer>just(a+b),
+    (a,b,c) -> Set.<Integer>just(a+b+c),
+    (a,b,c,d) -> a+b+c+d <100,
+    Tuple::tuple);
+     *
+     * }
+     * </pre>
+     *
+     * @param value1 top level Set
+     * @param value2 Nested Set
+     * @param value3 Nested Set
+     * @param value4 Nested Set
+     * @param filterFunction A filtering function, keeps values where the predicate holds
+     * @param yieldingFunction Generates a result per combination
+     * @return Set with an element per combination of nested publishers generated by the yielding function
+     */
+    public static <T1, T2, T3, R1, R2, R3, R> Set<R> forEach4(Set<? extends T1> value1,
+                                                                 Function<? super T1, ? extends Set<R1>> value2,
+                                                                 BiFunction<? super T1, ? super R1, ? extends Set<R2>> value3,
+                                                                 Fn3<? super T1, ? super R1, ? super R2, ? extends Set<R3>> value4,
+                                                                 Fn4<? super T1, ? super R1, ? super R2, ? super R3, Boolean> filterFunction,
+                                                                 Fn4<? super T1, ? super R1, ? super R2, ? super R3, ? extends R> yieldingFunction) {
+
+
+        return value1.flatMap(in -> {
+
+            Set<R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Set<R2> b = value3.apply(in,ina);
+                return b.flatMap(inb -> {
+                    Set<R3> c = value4.apply(in,ina,inb);
+                    return c.filter(in2->filterFunction.apply(in,ina,inb,in2))
+                            .map(in2 -> yieldingFunction.apply(in, ina, inb, in2));
+                });
+
+            });
+
+        });
+    }
+
+    /**
+     * Perform a For Comprehension over a Set, accepting 2 generating function.
+     * This results in a three level nested internal iteration over the provided Publishers.
+     *
+     * <pre>
+     * {@code
+     *
+     * import static Sets.forEach3;
+     *
+     * forEach(IntSet.range(1,10).boxed(),
+    a-> Set.iterate(a,i->i+1).limit(10),
+    (a,b) -> Set.<Integer>of(a+b),
+    Tuple::tuple);
+     *
+     * }
+     * </pre>
+     *
+     *
+     * @param value1 top level Set
+     * @param value2 Nested Set
+     * @param value3 Nested Set
+     * @param yieldingFunction Generates a result per combination
+     * @return Set with an element per combination of nested publishers generated by the yielding function
+     */
+    public static <T1, T2, R1, R2, R> Set<R> forEach3(Set<? extends T1> value1,
+                                                         Function<? super T1, ? extends Set<R1>> value2,
+                                                         BiFunction<? super T1, ? super R1, ? extends Set<R2>> value3,
+                                                         Fn3<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+
+        return value1.flatMap(in -> {
+
+            Set<R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Set<R2> b = value3.apply(in,ina);
+                return b.map(in2 -> yieldingFunction.apply(in, ina, in2));
+            });
+
+
+        });
+
+
+    }
+
+    /**
+     * Perform a For Comprehension over a Set, accepting 2 generating function.
+     * This results in a three level nested internal iteration over the provided Publishers.
+     * <pre>
+     * {@code
+     *
+     * import static Sets.forEach;
+     *
+     * forEach(IntSet.range(1,10).boxed(),
+    a-> Set.iterate(a,i->i+1).limit(10),
+    (a,b) -> Set.<Integer>of(a+b),
+    (a,b,c) ->a+b+c<10,
+    Tuple::tuple)
+    .toSetX();
+     * }
+     * </pre>
+     *
+     * @param value1 top level Set
+     * @param value2 Nested publisher
+     * @param value3 Nested publisher
+     * @param filterFunction A filtering function, keeps values where the predicate holds
+     * @param yieldingFunction Generates a result per combination
+     * @return
+     */
+    public static <T1, T2, R1, R2, R> Set<R> forEach3(Set<? extends T1> value1,
+                                                         Function<? super T1, ? extends Set<R1>> value2,
+                                                         BiFunction<? super T1, ? super R1, ? extends Set<R2>> value3,
+                                                         Fn3<? super T1, ? super R1, ? super R2, Boolean> filterFunction,
+                                                         Fn3<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
+
+
+        return value1.flatMap(in -> {
+
+            Set<R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Set<R2> b = value3.apply(in,ina);
+                return b.filter(in2->filterFunction.apply(in,ina,in2))
+                        .map(in2 -> yieldingFunction.apply(in, ina, in2));
+            });
+
+
+
+        });
+    }
+
+    /**
+     * Perform a For Comprehension over a Set, accepting an additonal generating function.
+     * This results in a two level nested internal iteration over the provided Publishers.
+     *
+     * <pre>
+     * {@code
+     *
+     *  import static Sets.forEach2;
+     *  forEach(IntSet.range(1, 10).boxed(),
+     *          i -> Set.range(i, 10), Tuple::tuple)
+    .forEach(System.out::println);
+
+    //(1, 1)
+    (1, 2)
+    (1, 3)
+    (1, 4)
+    ...
+     *
+     * }</pre>
+     *
+     * @param value1 top level Set
+     * @param value2 Nested publisher
+     * @param yieldingFunction Generates a result per combination
+     * @return
+     */
+    public static <T, R1, R> Set<R> forEach2(Set<? extends T> value1,
+                                                Function<? super T, Set<R1>> value2,
+                                                BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+
+
+        return value1.flatMap(in -> {
+
+            Set<R1> a = value2.apply(in);
+            return a.map(in2 -> yieldingFunction.apply(in,  in2));
+        });
+
+    }
+
+    /**
+     *
+     * <pre>
+     * {@code
+     *
+     *   import static Sets.forEach2;
+     *
+     *   forEach(IntSet.range(1, 10).boxed(),
+     *           i -> Set.range(i, 10),
+     *           (a,b) -> a>2 && b<10,
+     *           Tuple::tuple)
+    .forEach(System.out::println);
+
+    //(3, 3)
+    (3, 4)
+    (3, 5)
+    (3, 6)
+    (3, 7)
+    (3, 8)
+    (3, 9)
+    ...
+
+     *
+     * }</pre>
+     *
+     *
+     * @param value1 top level Set
+     * @param value2 Nested publisher
+     * @param filterFunction A filtering function, keeps values where the predicate holds
+     * @param yieldingFunction Generates a result per combination
+     * @return
+     */
+    public static <T, R1, R> Set<R> forEach2(Set<? extends T> value1,
+                                                Function<? super T, ? extends Set<R1>> value2,
+                                                BiFunction<? super T, ? super R1, Boolean> filterFunction,
+                                                BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
+
+
+        return value1.flatMap(in -> {
+
+            Set<R1> a = value2.apply(in);
+            return a.filter(in2->filterFunction.apply(in,in2))
+                    .map(in2 -> yieldingFunction.apply(in,  in2));
+        });
+    }
+
+    public static <T> Active<set,T> allTypeclasses(Set<T> array){
+        return Active.of(SetKind.widen(array), Sets.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<set,W2,R> mapM(Set<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Set<Higher<W2, R>> e = array.map(fn);
+        SetKind<Higher<W2, R>> lk = SetKind.widen(e);
+        return Nested.of(lk, Sets.Instances.definitions(), defs);
+    }
+    /**
+     * Companion class for creating Type Class instances for working with Sets
+     *
+     */
+    @UtilityClass
+    public static class Instances {
+
+        public static InstanceDefinitions<set> definitions() {
+            return new InstanceDefinitions<set>() {
+
+                @Override
+                public <T, R> Functor<set> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<set> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<set> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<set> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<set>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<set>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<set>> monadPlus(Monoid<Higher<set, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<set>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<set>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<set>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<set>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
+        /**
+         *
+         * Transform a set, mulitplying every element by 2
+         *
+         * <pre>
+         * {@code
+         *  SetKind<Integer> set = Sets.functor().map(i->i*2, SetKind.widen(Set.of(1,2,3));
+         *
+         *  //[2,4,6]
+         *
+         *
+         * }
+         * </pre>
+         *
+         * An example fluent api working with Sets
+         * <pre>
+         * {@code
+         *   SetKind<Integer> set = Sets.unit()
+        .unit("hello")
+        .then(h->Sets.functor().map((String v) ->v.length(), h))
+        .convert(SetKind::narrowK);
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A functor for Sets
+         */
+        public static <T,R>Functor<set> functor(){
+            BiFunction<SetKind<T>,Function<? super T, ? extends R>,SetKind<R>> map = Instances::map;
+            return General.functor(map);
+        }
+        /**
+         * <pre>
+         * {@code
+         * SetKind<String> set = Sets.unit()
+        .unit("hello")
+        .convert(SetKind::narrowK);
+
+        //Set.of("hello"))
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A factory for Sets
+         */
+        public static <T> Pure<set> unit(){
+            return General.<set,T>unit(Instances::of);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         * import static com.aol.cyclops.hkt.jdk.SetKind.widen;
+         * import static com.aol.cyclops.util.function.Lambda.l1;
+         *
+        Sets.zippingApplicative()
+        .ap(widen(Set.of(l1(this::multiplyByTwo))),widen(Set.of(1,2,3)));
+         *
+         * //[2,4,6]
+         * }
+         * </pre>
+         *
+         *
+         * Example fluent API
+         * <pre>
+         * {@code
+         * SetKind<Function<Integer,Integer>> setFn =Sets.unit()
+         *                                                  .unit(Lambda.l1((Integer i) ->i*2))
+         *                                                  .convert(SetKind::narrowK);
+
+        SetKind<Integer> set = Sets.unit()
+        .unit("hello")
+        .then(h->Sets.functor().map((String v) ->v.length(), h))
+        .then(h->Sets.zippingApplicative().ap(setFn, h))
+        .convert(SetKind::narrowK);
+
+        //Set.of("hello".length()*2))
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A zipper for Sets
+         */
+        public static <T,R> Applicative<set> zippingApplicative(){
+            BiFunction<SetKind< Function<T, R>>,SetKind<T>,SetKind<R>> ap = Instances::ap;
+            return General.applicative(functor(), unit(), ap);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         * import static com.aol.cyclops.hkt.jdk.SetKind.widen;
+         * SetKind<Integer> set  = Sets.monad()
+        .flatMap(i->widen(SetX.range(0,i)), widen(Set.of(1,2,3)))
+        .convert(SetKind::narrowK);
+         * }
+         * </pre>
+         *
+         * Example fluent API
+         * <pre>
+         * {@code
+         *    SetKind<Integer> set = Sets.unit()
+        .unit("hello")
+        .then(h->Sets.monad().flatMap((String v) ->Sets.unit().unit(v.length()), h))
+        .convert(SetKind::narrowK);
+
+        //Set.of("hello".length())
+         *
+         * }
+         * </pre>
+         *
+         * @return Type class with monad functions for Sets
+         */
+        public static <T,R> Monad<set> monad(){
+
+            BiFunction<Higher<set,T>,Function<? super T, ? extends Higher<set,R>>,Higher<set,R>> flatMap = Instances::flatMap;
+            return General.monad(zippingApplicative(), flatMap);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         *  SetKind<String> set = Sets.unit()
+        .unit("hello")
+        .then(h->Sets.monadZero().filter((String t)->t.startsWith("he"), h))
+        .convert(SetKind::narrowK);
+
+        //Set.of("hello"));
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return A filterable monad (with default value)
+         */
+        public static <T,R> MonadZero<set> monadZero(){
+            BiFunction<Higher<set,T>,Predicate<? super T>,Higher<set,T>> filter = Instances::filter;
+            Supplier<Higher<set, T>> zero = ()-> SetKind.widen(HashSet.empty());
+            return General.<set,T,R>monadZero(monad(), zero,filter);
+        }
+        /**
+         * <pre>
+         * {@code
+         *  SetKind<Integer> set = Sets.<Integer>monadPlus()
+        .plus(SetKind.widen(Set.of()), SetKind.widen(Set.of(10)))
+        .convert(SetKind::narrowK);
+        //Set.of(10))
+         *
+         * }
+         * </pre>
+         * @return Type class for combining Sets by concatenation
+         */
+        public static <T> MonadPlus<set> monadPlus(){
+            Monoid<SetKind<T>> m = Monoid.of(SetKind.widen(HashSet.<T>empty()), Instances::concat);
+            Monoid<Higher<set,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        /**
+         *
+         * <pre>
+         * {@code
+         *  Monoid<SetKind<Integer>> m = Monoid.of(SetKind.widen(Set.of()), (a,b)->a.isEmpty() ? b : a);
+        SetKind<Integer> set = Sets.<Integer>monadPlus(m)
+        .plus(SetKind.widen(Set.of(5)), SetKind.widen(Set.of(10)))
+        .convert(SetKind::narrowK);
+        //Set.of(5))
+         *
+         * }
+         * </pre>
+         *
+         * @param m Monoid to use for combining Sets
+         * @return Type class for combining Sets
+         */
+        public static <T> MonadPlus<set> monadPlus(Monoid<Higher<set,T>> m){
+            Monoid<Higher<set,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<set> monadPlusK(Monoid<SetKind<T>> m){
+            Monoid<Higher<set,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+
+        /**
+         * @return Type class for traversables with traverse / sequence operations
+         */
+        public static <C2,T> Traverse<set> traverse(){
+            BiFunction<Applicative<C2>,SetKind<Higher<C2, T>>,Higher<C2, SetKind<T>>> sequenceFn = (ap, set) -> {
+
+                Higher<C2,SetKind<T>> identity = ap.unit(SetKind.widen(HashSet.empty()));
+
+                BiFunction<Higher<C2,SetKind<T>>,Higher<C2,T>,Higher<C2,SetKind<T>>> combineToSet =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> concat(a, SetKind.just(b))),acc,next);
+
+                BinaryOperator<Higher<C2,SetKind<T>>> combineSets = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return concat(l1,l2);}),a,b); ;
+
+                return ReactiveSeq.fromIterable(set).reduce(identity,
+                        combineToSet,
+                        combineSets);
+
+
+            };
+            BiFunction<Applicative<C2>,Higher<set,Higher<C2, T>>,Higher<C2, Higher<set,T>>> sequenceNarrow  =
+                    (a,b) -> SetKind.widen2(sequenceFn.apply(a, SetKind.narrowK(b)));
+            return General.traverse(zippingApplicative(), sequenceNarrow);
+        }
+
+        /**
+         *
+         * <pre>
+         * {@code
+         * int sum  = Sets.foldable()
+        .foldLeft(0, (a,b)->a+b, SetKind.widen(Set.of(1,2,3,4)));
+
+        //10
+         *
+         * }
+         * </pre>
+         *
+         *
+         * @return Type class for folding / reduction operations
+         */
+        public static <T> Foldable<set> foldable(){
+            BiFunction<Monoid<T>,Higher<set,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(SetKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<set,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(SetKind.narrow(l)).reduce(m);
+            return General.foldable(foldRightFn, foldLeftFn);
+        }
+
+        private static  <T> SetKind<T> concat(SetKind<T> l1, SetKind<T> l2){
+            return SetKind.widen(l1.addAll(l2));
+        }
+        private <T> SetKind<T> of(T value){
+            return SetKind.widen(HashSet.of(value));
+        }
+        private static <T,R> SetKind<R> ap(SetKind<Function< T, R>> lt, SetKind<T> set){
+            return SetKind.widen(lt.toReactiveSeq().zip(set,(a, b)->a.apply(b)));
+        }
+        private static <T,R> Higher<set,R> flatMap(Higher<set,T> lt, Function<? super T, ? extends  Higher<set,R>> fn){
+            return SetKind.widen(SetKind.narrowK(lt).flatMap(fn.andThen(SetKind::narrowK)));
+        }
+        private static <T,R> SetKind<R> map(SetKind<T> lt, Function<? super T, ? extends R> fn){
+            return SetKind.widen(lt.map(fn));
+        }
+        private static <T> SetKind<T> filter(Higher<set,T> lt, Predicate<? super T> fn){
+            return SetKind.widen(SetKind.narrow(lt).filter(fn));
+        }
+        public static Unfoldable<set> unfoldable(){
+            return new Unfoldable<set>() {
+                @Override
+                public <R, T> Higher<set, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return SetKind.widen(ReactiveSeq.unfold(b,fn).collect(HashSet.collector()));
+
+                }
+            };
+        }
+    }
+
+
+
+}
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java
index 64cdb465..3547bb47 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Vectors.java
@@ -1,6 +1,9 @@
 package cyclops.companion.vavr;
 
+import com.aol.cyclops.vavr.hkt.ListKind;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.vector;
 import cyclops.collections.vavr.VavrVectorX;
 import com.aol.cyclops.vavr.hkt.VectorKind;
@@ -13,14 +16,22 @@
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.ListT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.collection.List;
 import io.vavr.collection.Vector;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.*;
 
 
@@ -302,15 +313,80 @@ public static <T, R1, R> Vector<R> forEach2(Vector<? extends T> value1,
                     .map(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+    public static <T> Active<vector,T> allTypeclasses(Vector<T> array){
+        return Active.of(VectorKind.widen(array), Vectors.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<vector,W2,R> mapM(Vector<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Vector<Higher<W2, R>> e = array.map(fn);
+        VectorKind<Higher<W2, R>> lk = VectorKind.widen(e);
+        return Nested.of(lk, Vectors.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Vectors
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<vector> definitions() {
+            return new InstanceDefinitions<vector>() {
+
+                @Override
+                public <T, R> Functor<vector> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<vector> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<vector> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<vector> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<vector>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<vector>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<vector>> monadPlus(Monoid<Higher<vector, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<vector>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<vector>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<vector>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<vector>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
         /**
          *
          * Transform a list, mulitplying every element by 2
@@ -487,7 +563,11 @@ public static <T> MonadPlus<vector> monadPlus(){
          * @param m Monoid to use for combining Vectors
          * @return Type class for combining Vectors
          */
-        public static <T> MonadPlus<vector> monadPlus(Monoid<VectorKind<T>> m){
+        public static <T> MonadPlus<vector> monadPlus(Monoid<Higher<vector,T>> m){
+            Monoid<Higher<vector,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<vector> monadPlusK(Monoid<VectorKind<T>> m){
             Monoid<Higher<vector,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -554,6 +634,15 @@ private static <T,R> Higher<vector,R> flatMap(Higher<vector,T> lt, Function<? su
         private static <T,R> VectorKind<R> map(VectorKind<T> lt, Function<? super T, ? extends R> fn){
             return VectorKind.widen(VectorKind.narrow(lt).map(in->fn.apply(in)));
         }
+        public static Unfoldable<vector> unfoldable(){
+            return new Unfoldable<vector>() {
+                @Override
+                public <R, T> Higher<vector, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return VectorKind.widen(ReactiveSeq.unfold(b,fn).collect(Vector.collector()));
+
+                }
+            };
+        }
     }
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
index c933dcf6..a5bc1c91 100644
--- a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
+++ b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
@@ -270,4 +270,12 @@ public FunctionalAdapter<lazy> adapter() {
         }
 
     }
-}
+    public static enum set implements WitnessType<set> {
+        INSTANCE;
+
+        @Override
+        public FunctionalAdapter<set> adapter() {
+            return null;
+        }
+
+    }}

From 919843d61221449adce42641d1f8106f1ae08f17 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Tue, 4 Jul 2017 23:31:30 +0100
Subject: [PATCH 06/30] migrate Option

---
 .../com/aol/cyclops/vavr/hkt/OptionKind.java  | 27 ++++--
 .../java/cyclops/companion/vavr/Options.java  | 82 ++++++++++++++++++-
 2 files changed, 99 insertions(+), 10 deletions(-)

diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
index b2328fab..fb55c46d 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
@@ -1,18 +1,29 @@
 package com.aol.cyclops.vavr.hkt;
 
 import java.util.Optional;
+import java.util.function.Function;
 
 
+import cyclops.companion.Optionals;
+import cyclops.companion.vavr.Futures;
+import cyclops.companion.vavr.Options;
 import cyclops.conversion.vavr.FromCyclopsReact;
 
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.companion.Optionals.OptionalKind;
 import cyclops.control.Eval;
 
+import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.option;
 import cyclops.monads.Witness;
 import cyclops.monads.Witness.optional;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.FutureT;
+import cyclops.monads.transformers.OptionalT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.vavr.collection.Iterator;
 import io.vavr.control.Option;
 import lombok.AccessLevel;
@@ -29,13 +40,15 @@
  */
 
 public interface OptionKind<T> extends Higher<option, T>, Option<T> {
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
+
+    default Active<option,T> allTypeclasses(){
+        return Active.of(this,Options.Instances.definitions());
+    }
+    default <W2,R> Nested<option,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Options.mapM(this,fn,defs);
+    }
+    default <W extends WitnessType<W>> OptionalT<W, T> liftM(W witness) {
+        return OptionalT.of(witness.adapter().unit(this.toJavaOptional()));
     }
     
     /**
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
index 13cb28d6..a2bbf884 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
@@ -1,5 +1,7 @@
 package cyclops.companion.vavr;
 
+import com.aol.cyclops.vavr.hkt.FutureKind;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
@@ -19,12 +21,17 @@
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.OptionalT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.concurrent.Future;
 import io.vavr.control.Option;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
@@ -577,7 +584,14 @@ public static <T1, T2, R> Option<R> zip(final Publisher<? extends T2> p, final O
     public static <T> Option<T> narrow(final Option<? extends T> optional) {
         return (Option<T>) optional;
     }
-
+    public static <T> Active<option,T> allTypeclasses(Option<T> option){
+        return Active.of(OptionKind.widen(option), Options.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<option,W2,R> mapM(Option<T> option, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Option<Higher<W2, R>> e = option.map(fn);
+        OptionKind<Higher<W2, R>> lk = OptionKind.widen(e);
+        return Nested.of(lk, Options.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Options
      * @author johnmcclean
@@ -586,7 +600,65 @@ public static <T> Option<T> narrow(final Option<? extends T> optional) {
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<option> definitions() {
+            return new InstanceDefinitions<option>() {
+
+                @Override
+                public <T, R> Functor<option> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<option> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<option> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<option> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<option>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<option>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<option>> monadPlus(Monoid<Higher<option, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<option>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<option>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<option>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<option>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
         /**
          *
          * Transform a option, mulitplying every element by 2
@@ -764,7 +836,11 @@ public static <T> MonadPlus<option> monadPlus(){
          * @param m Monoid to use for combining Options
          * @return Type class for combining Options
          */
-        public static <T> MonadPlus<option> monadPlus(Monoid<OptionKind<T>> m){
+        public static <T> MonadPlus<option> monadPlus(Monoid<Higher<option,T>> m){
+            Monoid<Higher<option,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<option> monadPlusK(Monoid<OptionKind<T>> m){
             Monoid<Higher<option,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }

From 4159154c9ab66d0f2d3ba65cdbeada4ffb9e006c Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Tue, 4 Jul 2017 23:37:53 +0100
Subject: [PATCH 07/30] add vavr fold

---
 .../com/aol/cyclops/vavr/hkt/ArrayKind.java   |  4 +
 .../com/aol/cyclops/vavr/hkt/FutureKind.java  |  4 +
 .../com/aol/cyclops/vavr/hkt/LazyKind.java    |  4 +
 .../com/aol/cyclops/vavr/hkt/OptionKind.java  |  5 +-
 .../com/aol/cyclops/vavr/hkt/QueueKind.java   | 14 +++
 .../com/aol/cyclops/vavr/hkt/StreamKind.java  |  6 ++
 .../com/aol/cyclops/vavr/hkt/TryKind.java     |  3 +
 .../java/cyclops/companion/vavr/Queues.java   | 89 ++++++++++++++++++-
 8 files changed, 126 insertions(+), 3 deletions(-)

diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
index ac29cdda..a612eac6 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
@@ -11,6 +11,7 @@
 import cyclops.typeclasses.Nested;
 import io.vavr.Lazy;
 import io.vavr.collection.Array;
+import io.vavr.collection.Queue;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.experimental.Delegate;
@@ -39,6 +40,9 @@ public <W2,R> Nested<array,W2,R> mapM(Function<? super T,? extends Higher<W2,R>>
         ArrayKind<Higher<W2, R>> lk = ArrayKind.widen(e);
         return Nested.of(lk, Arrays.Instances.definitions(), defs);
     }
+    public <R> ArrayKind<R> fold(Function<? super Array<? super T>,? extends Array<R>> op){
+        return widen(op.apply(boxed));
+    }
     public static <T> ArrayKind<T> of(T element) {
         return  widen(Array.of(element));
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
index adaee3d7..4be8dfe4 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
@@ -22,6 +22,7 @@
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
 import io.vavr.collection.Array;
+import io.vavr.collection.Queue;
 import io.vavr.concurrent.Future;
 import io.vavr.concurrent.Promise;
 import io.vavr.control.Option;
@@ -50,6 +51,9 @@ default <W2,R> Nested<future,W2,R> mapM(Function<? super T,? extends Higher<W2,R
     default <W extends WitnessType<W>> FutureT<W, T> liftM(W witness) {
         return FutureT.of(witness.adapter().unit(ToCyclopsReact.future(this)));
     }
+    default <R> FutureKind<R> fold(Function<? super Future<? super T>,? extends Future<R>> op){
+        return widen(op.apply(this));
+    }
     public static <T> FutureKind<T> failed(Throwable exception){
         return widen(Future.failed(exception));
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
index c3ed5f1d..5a0777fa 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
@@ -24,6 +24,7 @@
 import cyclops.typeclasses.Nested;
 import io.vavr.Lazy;
 import io.vavr.collection.Iterator;
+import io.vavr.concurrent.Future;
 import io.vavr.control.Option;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -48,6 +49,9 @@ public <W2,R> Nested<lazy,W2,R> mapM(Function<? super T,? extends Higher<W2,R>>
         LazyKind<Higher<W2, R>> lk = LazyKind.widen(e);
         return Nested.of(lk, Lazys.Instances.definitions(), defs);
     }
+    public <R> LazyKind<R> fold(Function<? super Lazy<? super T>,? extends Lazy<R>> op){
+        return widen(op.apply(boxed));
+    }
     public <T,W extends WitnessType<W>> EvalT<W, T> liftM(Lazy<T> lazy, W witness) {
         return EvalT.of(witness.adapter().unit(ToCyclopsReact.eval(lazy)));
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
index fb55c46d..3fee12ad 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
@@ -25,6 +25,7 @@
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
 import io.vavr.collection.Iterator;
+import io.vavr.concurrent.Future;
 import io.vavr.control.Option;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -50,7 +51,9 @@ default <W2,R> Nested<option,W2,R> mapM(Function<? super T,? extends Higher<W2,R
     default <W extends WitnessType<W>> OptionalT<W, T> liftM(W witness) {
         return OptionalT.of(witness.adapter().unit(this.toJavaOptional()));
     }
-    
+    default <R> OptionKind<R> fold(Function<? super Option<? super T>,? extends Option<R>> op){
+        return widen(op.apply(this));
+    }
     /**
      * @return Get the empty Option (single instance)
      */
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
index b7e92f95..b2c7e4bb 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
@@ -19,8 +19,13 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.vavr.Lists;
+import cyclops.companion.vavr.Queues;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.queue;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.vavr.collection.LinearSeq;
 import io.vavr.collection.Queue;
 import lombok.AccessLevel;
@@ -38,7 +43,16 @@
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class QueueKind<T> implements Higher<queue, T> {
+    public Active<queue,T> allTypeclasses(){
+        return Active.of(this, Queues.Instances.definitions());
+    }
 
+    public <W2,R> Nested<queue,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Queues.mapM(boxed,fn,defs);
+    }
+    public <R> QueueKind<R> fold(Function<? super Queue<? super T>,? extends Queue<R>> op){
+        return widen(op.apply(boxed));
+    }
 
     public static <T> QueueKind<T> of(T element) {
         return  widen(Queue.of(element));
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
index 7a98704c..224bdded 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
@@ -4,6 +4,7 @@
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.stream;
 import cyclops.stream.ReactiveSeq;
+import io.vavr.concurrent.Future;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
@@ -12,6 +13,8 @@
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 
+import java.util.function.Function;
+
 /**
  * Simulates Higher Kinded Types for Vavr Stream's
  * 
@@ -25,6 +28,9 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final class StreamKind<T> implements Higher<stream, T>, Publisher<T>, Stream<T>{
 
+    public <R> StreamKind<R> fold(Function<? super Stream<? super T>,? extends Stream<R>> op){
+        return widen(op.apply(boxed));
+    }
     /**
      * Construct a HKT encoded completed Stream
      * 
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
index e7a3e980..6918d6db 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
@@ -47,6 +47,9 @@ default <W2,R> Nested<tryType,W2,R> mapM(Function<? super T,? extends Higher<W2,
     default <W extends WitnessType<W>> XorT<W,Throwable, T> liftM(W witness) {
         return XorT.of(witness.adapter().unit(ToCyclopsReact.toTry(this).asXor()));
     }
+    default <R> TryKind<R> fold(Function<? super Try<? super T>,? extends Try<R>> op){
+        return widen(op.apply(this));
+    }
     
     public static <T> TryKind<T> failed(Throwable exception){
         return widen(Try.failure(exception));
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
index bf65758c..7eaa7837 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
@@ -1,6 +1,9 @@
 package cyclops.companion.vavr;
 
+import com.aol.cyclops.vavr.hkt.ListKind;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.queue;
 import com.aol.cyclops.vavr.hkt.QueueKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -10,14 +13,22 @@
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.collection.List;
 import io.vavr.collection.Queue;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
@@ -299,14 +310,79 @@ public static <T, R1, R> Queue<R> forEach2(Queue<? extends T> value1,
                     .map(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+    public static <T> Active<queue,T> allTypeclasses(Queue<T> array){
+        return Active.of(QueueKind.widen(array), Queues.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<queue,W2,R> mapM(Queue<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Queue<Higher<W2, R>> e = array.map(fn);
+        QueueKind<Higher<W2, R>> lk = QueueKind.widen(e);
+        return Nested.of(lk, Queues.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Queues
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
-
+        public static InstanceDefinitions<queue> definitions() {
+            return new InstanceDefinitions<queue>() {
+
+                @Override
+                public <T, R> Functor<queue> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<queue> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<queue> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<queue> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<queue>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<queue>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<queue>> monadPlus(Monoid<Higher<queue, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<queue>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<queue>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<queue>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<queue>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
 
         /**
          *
@@ -551,6 +627,15 @@ private static <T,R> Higher<queue,R> flatMap(Higher<queue,T> lt, Function<? supe
         private static <T,R> QueueKind<R> map(QueueKind<T> lt, Function<? super T, ? extends R> fn){
             return QueueKind.widen(QueueKind.narrow(lt).map(in->fn.apply(in)));
         }
+        public static Unfoldable<queue> unfoldable(){
+            return new Unfoldable<queue>() {
+                @Override
+                public <R, T> Higher<queue, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return QueueKind.widen(ReactiveSeq.unfold(b,fn).collect(Queue.collector()));
+
+                }
+            };
+        }
     }
 
 

From 21a5e2d59d1d3993a097f68ce7c2377bdf0993b8 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Tue, 4 Jul 2017 23:42:56 +0100
Subject: [PATCH 08/30] vavr migration

---
 .../com/aol/cyclops/vavr/hkt/StreamKind.java  | 21 +++++
 .../java/cyclops/companion/vavr/Streams.java  | 94 ++++++++++++++++++-
 2 files changed, 113 insertions(+), 2 deletions(-)

diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
index 224bdded..d0f4adfa 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
@@ -1,9 +1,19 @@
 package com.aol.cyclops.vavr.hkt;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.collections.vavr.VavrVectorX;
+import cyclops.companion.vavr.Streams;
+import cyclops.companion.vavr.Vectors;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.stream;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.ListT;
+import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import io.vavr.collection.Vector;
 import io.vavr.concurrent.Future;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
@@ -28,6 +38,17 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final class StreamKind<T> implements Higher<stream, T>, Publisher<T>, Stream<T>{
 
+    public Active<stream,T> allTypeclasses(){
+        return Active.of(this, Streams.Instances.definitions());
+    }
+
+    public <W2,R> Nested<stream,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Streams.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> StreamT<W, T> liftM(W witness) {
+        return StreamT.of(witness.adapter().unit(ReactiveSeq.fromStream(boxed.toJavaStream())));
+    }
     public <R> StreamKind<R> fold(Function<? super Stream<? super T>,? extends Stream<R>> op){
         return widen(op.apply(boxed));
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index 9393d219..89a87b15 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -1,6 +1,9 @@
 package cyclops.companion.vavr;
 
+import com.aol.cyclops.vavr.hkt.ListKind;
+import cyclops.control.Maybe;
 import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.stream;
 import com.aol.cyclops.vavr.hkt.StreamKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -10,14 +13,22 @@
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.collection.List;
 import io.vavr.collection.Stream;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
@@ -299,6 +310,14 @@ public static <T, R1, R> Stream<R> forEach2(Stream<? extends T> value1,
                     .map(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+    public static <T> Active<stream,T> allTypeclasses(Stream<T> array){
+        return Active.of(StreamKind.widen(array), Streams.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<stream,W2,R> mapM(Stream<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Stream<Higher<W2, R>> e = array.map(fn);
+        StreamKind<Higher<W2, R>> lk = StreamKind.widen(e);
+        return Nested.of(lk, Streams.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Streams
      * @author johnmcclean
@@ -307,7 +326,65 @@ public static <T, R1, R> Stream<R> forEach2(Stream<? extends T> value1,
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<stream> definitions() {
+            return new InstanceDefinitions<stream>() {
+
+                @Override
+                public <T, R> Functor<stream> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<stream> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<stream> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<stream> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<stream>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<stream>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<stream>> monadPlus(Monoid<Higher<stream, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<stream>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<stream>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<stream>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<stream>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
         /**
          *
          * Transform a list, mulitplying every element by 2
@@ -484,7 +561,11 @@ public static <T> MonadPlus<stream> monadPlus(){
          * @param m Monoid to use for combining Streams
          * @return Type class for combining Streams
          */
-        public static <T> MonadPlus<stream> monadPlus(Monoid<StreamKind<T>> m){
+        public static <T> MonadPlus<stream> monadPlus(Monoid<Higher<stream,T>> m){
+            Monoid<Higher<stream,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<stream> monadPlusK(Monoid<StreamKind<T>> m){
             Monoid<Higher<stream,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -551,6 +632,15 @@ private static <T,R> Higher<stream,R> flatMap(Higher<stream,T> lt, Function<? su
         private static <T,R> StreamKind<R> map(StreamKind<T> lt, Function<? super T, ? extends R> fn){
             return StreamKind.widen(StreamKind.narrow(lt).map(in->fn.apply(in)));
         }
+        public static Unfoldable<stream> unfoldable(){
+            return new Unfoldable<stream>() {
+                @Override
+                public <R, T> Higher<stream, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return StreamKind.widen(ReactiveSeq.unfold(b,fn).collect(Stream.collector()));
+
+                }
+            };
+        }
     }
 
 

From d1d624838e412740a64ee4d00adeba7935907961 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 11:40:53 +0100
Subject: [PATCH 09/30] Vavr migration

---
 .../com/aol/cyclops/vavr/hkt/ArrayKind.java   |   5 +
 .../com/aol/cyclops/vavr/hkt/FutureKind.java  |   6 +
 .../com/aol/cyclops/vavr/hkt/LazyKind.java    |   6 +
 .../com/aol/cyclops/vavr/hkt/ListKind.java    |   6 +
 .../com/aol/cyclops/vavr/hkt/OptionKind.java  |   6 +
 .../com/aol/cyclops/vavr/hkt/QueueKind.java   |   7 +
 .../com/aol/cyclops/vavr/hkt/SetKind.java     |  40 ++--
 .../com/aol/cyclops/vavr/hkt/StreamKind.java  |   6 +
 .../com/aol/cyclops/vavr/hkt/TryKind.java     |   6 +
 .../com/aol/cyclops/vavr/hkt/VectorKind.java  |   6 +
 .../java/cyclops/companion/vavr/Arrays.java   | 210 +++++++++++++++--
 .../java/cyclops/companion/vavr/Eithers.java  |  44 +++-
 .../java/cyclops/companion/vavr/Futures.java  | 217 ++++++++++++++++--
 .../java/cyclops/companion/vavr/Lazys.java    | 211 +++++++++++++++--
 .../java/cyclops/companion/vavr/Lists.java    | 212 +++++++++++++++--
 .../java/cyclops/companion/vavr/Options.java  | 206 +++++++++++++++--
 .../java/cyclops/companion/vavr/Queues.java   | 216 +++++++++++++++--
 .../java/cyclops/companion/vavr/Sets.java     | 217 ++++++++++++++++--
 .../java/cyclops/companion/vavr/Streams.java  |  65 ++++--
 .../java/cyclops/companion/vavr/Trys.java     |  53 ++++-
 .../main/java/cyclops/monads/VavrWitness.java |  20 +-
 21 files changed, 1573 insertions(+), 192 deletions(-)

diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
index a612eac6..58d2b79f 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ArrayKind.java
@@ -11,6 +11,7 @@
 import cyclops.typeclasses.Nested;
 import io.vavr.Lazy;
 import io.vavr.collection.Array;
+import io.vavr.collection.List;
 import io.vavr.collection.Queue;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -30,7 +31,11 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class ArrayKind<T> implements Higher<array, T>{
 
+    public static <T> Higher<array,T> widenK(final Array<T> completableList) {
 
+        return new ArrayKind<>(
+                completableList);
+    }
     public Active<array,T> allTypeclasses(){
         return Active.of(this, Arrays.Instances.definitions());
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
index 4be8dfe4..1e660478 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/FutureKind.java
@@ -22,6 +22,7 @@
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
 import io.vavr.collection.Array;
+import io.vavr.collection.List;
 import io.vavr.collection.Queue;
 import io.vavr.concurrent.Future;
 import io.vavr.concurrent.Promise;
@@ -42,6 +43,11 @@
 
 public interface FutureKind<T> extends Higher<future, T>, Future<T> {
 
+    public static <T> Higher<future,T> widenK(final Future<T> completableList) {
+
+        return new FutureKind.Box<>(
+                completableList);
+    }
     default Active<future,T> allTypeclasses(){
         return Active.of(this, Futures.Instances.definitions());
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
index 5a0777fa..b47310ba 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/LazyKind.java
@@ -23,6 +23,7 @@
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
 import io.vavr.Lazy;
+import io.vavr.collection.Array;
 import io.vavr.collection.Iterator;
 import io.vavr.concurrent.Future;
 import io.vavr.control.Option;
@@ -41,6 +42,11 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final  class LazyKind<T> implements Higher<lazy, T> {
 
+    public static <T> Higher<lazy,T> widenK(final Lazy<T> completableList) {
+
+        return new LazyKind<>(
+                completableList);
+    }
     public  Active<lazy,T> allTypeclasses(){
         return Active.of(this, Lazys.Instances.definitions());
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
index 45a6cca7..d18c2427 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/ListKind.java
@@ -89,6 +89,12 @@ public static <T> ListKind<T> widen(final List<T> completableList) {
                                 completableList);
     }
 
+    public static <T> Higher<list,T> widenK(final List<T> completableList) {
+
+        return new Box<>(
+                completableList);
+    }
+
     /**
      * Widen a ListKind nested inside another HKT encoded type
      * 
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
index 3fee12ad..4e310086 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/OptionKind.java
@@ -25,6 +25,7 @@
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
 import io.vavr.collection.Iterator;
+import io.vavr.collection.List;
 import io.vavr.concurrent.Future;
 import io.vavr.control.Option;
 import lombok.AccessLevel;
@@ -42,6 +43,11 @@
 
 public interface OptionKind<T> extends Higher<option, T>, Option<T> {
 
+    public static <T> Higher<option,T> widenK(final Option<T> completableList) {
+
+        return new OptionKind.Box<>(
+                completableList);
+    }
     default Active<option,T> allTypeclasses(){
         return Active.of(this,Options.Instances.definitions());
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
index b2c7e4bb..0710d5d0 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/QueueKind.java
@@ -26,6 +26,7 @@
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
+import io.vavr.collection.Array;
 import io.vavr.collection.LinearSeq;
 import io.vavr.collection.Queue;
 import lombok.AccessLevel;
@@ -43,6 +44,12 @@
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class QueueKind<T> implements Higher<queue, T> {
+
+    public static <T> Higher<queue,T> widenK(final Queue<T> completableList) {
+
+        return new QueueKind<>(
+                completableList);
+    }
     public Active<queue,T> allTypeclasses(){
         return Active.of(this, Queues.Instances.definitions());
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
index a802fc3d..5a91463f 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
@@ -1,15 +1,15 @@
 package com.aol.cyclops.vavr.hkt;
 
 import com.aol.cyclops2.hkt.Higher;
-import cyclops.collections.vavr.VavrSetX;
 import cyclops.companion.vavr.Sets;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.set;
 import cyclops.monads.WitnessType;
-import cyclops.monads.transformers.SetT;
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
+import io.vavr.collection.Array;
 import io.vavr.collection.HashSet;
 import io.vavr.collection.Set;
 import lombok.AccessLevel;
@@ -30,17 +30,22 @@
  * @param <T> Data type stored within the Set
  */
 
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class SetKind<T> implements Higher<set, T>, Publisher<T>, Set<T> {
 
-public interface SetKind<T> extends Higher<set, T>, Publisher<T>, Set<T> {
+    public static <T> Higher<set,T> widenK(final HashSet<T> completableList) {
 
-    default Active<set,T> allTypeclasses(){
+        return new SetKind<>(
+                completableList);
+    }
+    public Active<set,T> allTypeclasses(){
         return Active.of(this, Sets.Instances.definitions());
     }
 
-    default <W2,R> Nested<set,W2,R> mapM(Function<? super T, ? extends Higher<W2, R>> fn, InstanceDefinitions<W2> defs){
-        return Sets.mapM(this,fn,defs);
+    public <W2,R> Nested<set,W2,R> mapM(Function<? super T, ? extends Higher<W2, R>> fn, InstanceDefinitions<W2> defs){
+        return Sets.mapM(boxed,fn,defs);
     }
-    default <R> SetKind<R> fold(Function<? super Set<? super T>, ? extends Set<R>> op){
+    public <R> SetKind<R> fold(Function<? super Set<? super T>, ? extends HashSet<R>> op){
         return widen(op.apply(this));
     }
 
@@ -74,9 +79,9 @@ public static <T> SetKind<T> empty() {
      * @param completableSet Set to widen to a SetKind
      * @return SetKind encoding HKT info about Sets
      */
-    public static <T> SetKind<T> widen(final Set<T> completableSet) {
+    public static <T> SetKind<T> widen(final HashSet<T> completableSet) {
 
-        return new Box<>(
+        return new SetKind<>(
                                 completableSet);
     }
 
@@ -95,7 +100,7 @@ public static <C2, T> Higher<C2, Higher<set, T>> widen2(Higher<C2, SetKind<T>> f
 
     public static <T> SetKind<T> widen(final Publisher<T> completableSet) {
 
-        return new Box<>(
+        return new SetKind<>(
                                 HashSet.ofAll((Iterable<T>)ReactiveSeq.fromPublisher(completableSet)));
     }
 
@@ -115,27 +120,26 @@ public static <T> SetKind<T> narrowK(final Higher<set, T> future) {
      * @param set Type Constructor to convert back into narrowed type
      * @return Set from Higher Kinded Type
      */
-    public static <T> Set<T> narrow(final Higher<set, T> set) {
+    public static <T> HashSet<T> narrow(final Higher<set, T> set) {
 
         return ((SetKind<T>) set).narrow();
 
     }
-    public Set<T> narrow();
-    public ReactiveSeq<T> toReactiveSeq();
 
-    @AllArgsConstructor(access = AccessLevel.PRIVATE)
-    static final class Box<T> implements SetKind<T> {
+
 
         @Delegate
-        private final Set<T> boxed;
+        private final HashSet<T> boxed;
         public ReactiveSeq<T> toReactiveSeq(){
             return ReactiveSeq.fromIterable(boxed);
         }
 
+
+
         /**
          * @return wrapped Set
          */
-        public Set<T> narrow() {
+        public HashSet<T> narrow() {
             return boxed;
         }
 
@@ -177,5 +181,5 @@ public String toString() {
 
 
 
-    }
+
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
index d0f4adfa..1fc58a33 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/StreamKind.java
@@ -13,6 +13,7 @@
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
+import io.vavr.collection.Array;
 import io.vavr.collection.Vector;
 import io.vavr.concurrent.Future;
 import org.reactivestreams.Publisher;
@@ -42,6 +43,11 @@ public Active<stream,T> allTypeclasses(){
         return Active.of(this, Streams.Instances.definitions());
     }
 
+    public static <T> Higher<stream,T> widenK(final Stream<T> completableList) {
+
+        return new StreamKind<>(
+                completableList);
+    }
     public <W2,R> Nested<stream,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         return Streams.mapM(boxed,fn,defs);
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
index 6918d6db..f98d4482 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/TryKind.java
@@ -15,6 +15,7 @@
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
+import io.vavr.collection.List;
 import io.vavr.concurrent.Future;
 import io.vavr.concurrent.Promise;
 import io.vavr.control.Option;
@@ -38,6 +39,11 @@
 
 public interface TryKind<T> extends Higher<tryType, T>, Try<T> {
 
+    public static <T> Higher<tryType,T> widenK(final Try<T> completableList) {
+
+        return new TryKind.Box<>(
+                completableList);
+    }
     default Active<tryType,T> allTypeclasses(){
         return Active.of(this, Trys.Instances.definitions());
     }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
index 495d8b69..2e5781d3 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/VectorKind.java
@@ -30,6 +30,7 @@
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
+import io.vavr.collection.Array;
 import io.vavr.collection.Vector;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -47,6 +48,11 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class VectorKind<T> implements Higher<vector, T>{
 
+    public static <T> Higher<vector,T> widenK(final Vector<T> completableList) {
+
+        return new VectorKind<>(
+                completableList);
+    }
     public Active<vector,T> allTypeclasses(){
         return Active.of(this, Vectors.Instances.definitions());
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
index e300c99a..4a58c57c 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
@@ -1,27 +1,34 @@
 package cyclops.companion.vavr;
 
 
-import com.aol.cyclops.vavr.hkt.LazyKind;
+import com.aol.cyclops.vavr.hkt.*;
 import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.FromJDK;
 import cyclops.conversion.vavr.FromJooqLambda;
-import cyclops.monads.VavrWitness;
-import cyclops.monads.VavrWitness.array;
-import com.aol.cyclops.vavr.hkt.ArrayKind;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
-import cyclops.monads.AnyM;
 
+import cyclops.monads.VavrWitness.*;
+import cyclops.monads.VavrWitness.*;
+import cyclops.monads.VavrWitness.either;
+import cyclops.monads.VavrWitness.future;
+import cyclops.monads.VavrWitness.list;
+import cyclops.monads.VavrWitness.tryType;
+import cyclops.monads.Witness.*;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -29,20 +36,32 @@
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
 import io.vavr.Lazy;
-import io.vavr.collection.Array;
+import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
+import io.vavr.control.Either;
+import io.vavr.control.Option;
+import io.vavr.control.Try;
 import lombok.experimental.UtilityClass;
 import org.jooq.lambda.tuple.Tuple;
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 
+import static com.aol.cyclops.vavr.hkt.ArrayKind.widen;
 
-public class Arrays {
 
+public class Arrays {
 
+    public static  <W1,T> Coproduct<W1,array,T> coproduct(Array<T> list, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(list)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,array,T> xorM(Array<T> type){
+        return XorM.right(anyM(type));
+    }
    
     public static <T> AnyMSeq<array,T> anyM(Array<T> option) {
         return AnyM.ofSeq(option, array.INSTANCE);
@@ -317,11 +336,11 @@ public static <T, R1, R> Array<R> forEach2(Array<? extends T> value1,
         });
     }
     public static <T> Active<array,T> allTypeclasses(Array<T> array){
-        return Active.of(ArrayKind.widen(array), Instances.definitions());
+        return Active.of(widen(array), Instances.definitions());
     }
     public static <T,W2,R> Nested<array,W2,R> mapM(Array<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Array<Higher<W2, R>> e = array.map(fn);
-        ArrayKind<Higher<W2, R>> lk = ArrayKind.widen(e);
+        ArrayKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Arrays.Instances.definitions(), defs);
     }
     /**
@@ -530,7 +549,7 @@ public static <T,R> Monad<array> monad(){
          */
         public static <T,R> MonadZero<array> monadZero(){
 
-            return General.monadZero(monad(), ArrayKind.widen(Array.empty()));
+            return General.monadZero(monad(), widen(Array.empty()));
         }
         /**
          * <pre>
@@ -545,7 +564,7 @@ public static <T,R> MonadZero<array> monadZero(){
          * @return Type class for combining Arrays by concatenation
          */
         public static <T> MonadPlus<array> monadPlus(){
-            Monoid<ArrayKind<T>> m = Monoid.of(ArrayKind.widen(Array.empty()), Instances::concat);
+            Monoid<ArrayKind<T>> m = Monoid.of(widen(Array.empty()), Instances::concat);
             Monoid<Higher<array,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -577,7 +596,7 @@ public static Unfoldable<array> unfoldable(){
             return new Unfoldable<array>() {
                 @Override
                 public <R, T> Higher<array, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
-                    return ArrayKind.widen(ReactiveSeq.unfold(b,fn).collect(Array.collector()));
+                    return widen(ReactiveSeq.unfold(b,fn).collect(Array.collector()));
 
                 }
             };
@@ -589,12 +608,12 @@ public static <C2,T> Traverse<array> traverse(){
 
             BiFunction<Applicative<C2>,ArrayKind<Higher<C2, T>>,Higher<C2, ArrayKind<T>>> sequenceFn = (ap, list) -> {
 
-                Higher<C2,ArrayKind<T>> identity = ap.unit(ArrayKind.widen(Array.empty()));
+                Higher<C2,ArrayKind<T>> identity = ap.unit(widen(Array.empty()));
 
-                BiFunction<Higher<C2,ArrayKind<T>>,Higher<C2,T>,Higher<C2,ArrayKind<T>>> combineToArray =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> ArrayKind.widen(ArrayKind.narrow(a).append(b))),
+                BiFunction<Higher<C2,ArrayKind<T>>,Higher<C2,T>,Higher<C2,ArrayKind<T>>> combineToArray =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(ArrayKind.narrow(a).append(b))),
                         acc,next);
 
-                BinaryOperator<Higher<C2,ArrayKind<T>>> combineArrays = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> ArrayKind.widen(ArrayKind.narrow(l1).appendAll(l2.narrow()))),a,b); ;
+                BinaryOperator<Higher<C2,ArrayKind<T>>> combineArrays = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> widen(ArrayKind.narrow(l1).appendAll(l2.narrow()))),a,b); ;
 
                 return ReactiveSeq.fromIterable(ArrayKind.narrow(list))
                         .reduce(identity,
@@ -631,21 +650,166 @@ public static <T> Foldable<array> foldable(){
 
         private static  <T> ArrayKind<T> concat(ArrayKind<T> l1, ArrayKind<T> l2){
 
-            return ArrayKind.widen(l1.appendAll(ArrayKind.narrow(l2)));
+            return widen(l1.appendAll(ArrayKind.narrow(l2)));
 
         }
 
         private static <T,R> ArrayKind<R> ap(ArrayKind<Function< T, R>> lt, ArrayKind<T> list){
-            return ArrayKind.widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toArray());
+            return widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toArray());
         }
         private static <T,R> Higher<array,R> flatMap(Higher<array,T> lt, Function<? super T, ? extends  Higher<array,R>> fn){
-            return ArrayKind.widen(ArrayKind.narrow(lt).flatMap(fn.andThen(ArrayKind::narrow)));
+            return widen(ArrayKind.narrow(lt).flatMap(fn.andThen(ArrayKind::narrow)));
         }
         private static <T,R> ArrayKind<R> map(ArrayKind<T> lt, Function<? super T, ? extends R> fn){
-            return ArrayKind.widen(ArrayKind.narrow(lt).map(in->fn.apply(in)));
+            return widen(ArrayKind.narrow(lt).map(in->fn.apply(in)));
         }
     }
 
+    public static interface Nesteds{
+
+
+        public static <T> Nested<array,option,T> option(Array<Option<T>> type){
+            return Nested.of(widen(type.map(OptionKind::widen)),Instances.definitions(),Options.Instances.definitions());
+        }
+        public static <T> Nested<array,tryType,T> arrayTry(Array<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<array,future,T> future(Array<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<array,lazy,T> lazy(Array<Lazy<T>> nested){
+            return Nested.of(widen(nested.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <L, R> Nested<array,Higher<either,L>, R> either(Array<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<array,VavrWitness.queue,T> queue(Array<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)), Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <T> Nested<array,VavrWitness.stream,T> stream(Array<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<array,list,T> list(Array<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<array,array,T> array(Array<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<array,vector,T> vector(Array<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<array,VavrWitness.set,T> set(Array<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<array,reactiveSeq,T> reactiveSeq(Array<ReactiveSeq<T>> nested){
+            ArrayKind<ReactiveSeq<T>> x = widen(nested);
+            ArrayKind<Higher<reactiveSeq,T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<array,maybe,T> maybe(Array<Maybe<T>> nested){
+            ArrayKind<Maybe<T>> x = widen(nested);
+            ArrayKind<Higher<maybe,T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<array,eval,T> eval(Array<Eval<T>> nested){
+            ArrayKind<Eval<T>> x = widen(nested);
+            ArrayKind<Higher<eval,T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<array,Witness.future,T> cyclopsFuture(Array<cyclops.async.Future<T>> nested){
+            ArrayKind<cyclops.async.Future<T>> x = widen(nested);
+            ArrayKind<Higher<Witness.future,T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<array,Higher<xor,S>, P> xor(Array<Xor<S, P>> nested){
+            ArrayKind<Xor<S, P>> x = widen(nested);
+            ArrayKind<Higher<Higher<xor,S>, P>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<array,Higher<reader,S>, T> reader(Array<Reader<S, T>> nested){
+            ArrayKind<Reader<S, T>> x = widen(nested);
+            ArrayKind<Higher<Higher<reader,S>, T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<array,Higher<Witness.tryType,S>, P> cyclopsTry(Array<cyclops.control.Try<P, S>> nested){
+            ArrayKind<cyclops.control.Try<P, S>> x = widen(nested);
+            ArrayKind<Higher<Higher<Witness.tryType,S>, P>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<array,optional,T> optional(Array<Optional<T>> nested){
+            ArrayKind<Optional<T>> x = widen(nested);
+            ArrayKind<Higher<optional,T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<array,completableFuture,T> completableFuture(Array<CompletableFuture<T>> nested){
+            ArrayKind<CompletableFuture<T>> x = widen(nested);
+            ArrayKind<Higher<completableFuture,T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<array,Witness.stream,T> javaStream(Array<java.util.stream.Stream<T>> nested){
+            ArrayKind<java.util.stream.Stream<T>> x = widen(nested);
+            ArrayKind<Higher<Witness.stream,T>> y = (ArrayKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,array,T> reactiveSeq(ReactiveSeq<Array<T>> nested){
+                ReactiveSeq<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,array,T> maybe(Maybe<Array<T>> nested){
+                Maybe<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,array,T> eval(Eval<Array<T>> nested){
+                Eval<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,array,T> cyclopsFuture(cyclops.async.Future<Array<T>> nested){
+                cyclops.async.Future<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,array, P> xor(Xor<S, Array<P>> nested){
+                Xor<S, Higher<array,P>> x = nested.map(ArrayKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,array, T> reader(Reader<S, Array<T>> nested){
+
+                Reader<S, Higher<array, T>>  x = nested.map(ArrayKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,array, P> cyclopsTry(cyclops.control.Try<Array<P>, S> nested){
+                cyclops.control.Try<Higher<array,P>, S> x = nested.map(ArrayKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,array,T> optional(Optional<Array<T>> nested){
+                Optional<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,array,T> completableFuture(CompletableFuture<Array<T>> nested){
+                CompletableFuture<Higher<array,T>> x = nested.thenApply(ArrayKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,array,T> javaStream(java.util.stream.Stream<Array<T>> nested){
+                java.util.stream.Stream<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
 
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
index afc15dff..6dc0a20b 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
@@ -1,15 +1,37 @@
 package cyclops.companion.vavr;
 
-
+import io.vavr.collection.*;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.EitherKind;
+import com.aol.cyclops.vavr.hkt.ListKind;
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.companion.Monoids;
 import cyclops.control.Maybe;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
-import cyclops.monads.Vavr;
-import cyclops.monads.VavrWitness;
+import cyclops.monads.*;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
 import com.aol.cyclops2.types.Value;
 import com.aol.cyclops2.types.anyM.AnyMValue;
@@ -18,21 +40,17 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
-import cyclops.monads.AnyM;
 import cyclops.monads.VavrWitness.either;
-import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.comonad.ComonadByPure;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.monad.*;
+import io.vavr.collection.List;
 import io.vavr.control.Either;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
@@ -49,6 +67,14 @@
  */
 @UtilityClass
 public class Eithers {
+
+
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproduct(Either<L,T> either, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(EitherKind.widen(either)),def1,Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorM(Either<L,T> type){
+        return XorM.right(anyM(type));
+    }
     public static <L, R> Either<L, R> xor(Xor<L, R> value) {
         Xor<L, R> xor = (Xor) value.toXor();
         return xor.visit(l -> Either.left(l), r -> Either.right(r));
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
index 1ff44830..0e8b566b 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
@@ -1,14 +1,41 @@
 package cyclops.companion.vavr;
 
-
+import cyclops.monads.VavrWitness.list;
+import cyclops.monads.VavrWitness.stream;
+import cyclops.monads.VavrWitness.tryType;
+import io.vavr.Lazy;
+import io.vavr.collection.*;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.ArrayKind;
+import com.aol.cyclops.vavr.hkt.ListKind;
 import com.aol.cyclops2.react.Status;
 import com.aol.cyclops2.react.collectors.lazy.Blocker;
 import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
-import cyclops.monads.Vavr;
-import cyclops.monads.VavrWitness;
+import cyclops.monads.*;
 import cyclops.monads.VavrWitness.future;
 import com.aol.cyclops.vavr.hkt.FutureKind;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
@@ -21,14 +48,9 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
-import cyclops.monads.AnyM;
-import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.FutureT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -42,7 +64,7 @@
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
-import java.util.List;
+
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
@@ -50,7 +72,9 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
+
+
+import static com.aol.cyclops.vavr.hkt.FutureKind.widen;
 
 /**
  * Utilty methods for working with JDK CompletableFutures
@@ -60,6 +84,14 @@
  */
 @UtilityClass
 public class Futures {
+
+
+    public static  <W1,T> Coproduct<W1,future,T> coproduct(Future<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,future,T> xorM(Future<T> type){
+        return XorM.right(anyM(type));
+    }
     public static <T> void subscribe(final Subscriber<? super T> sub, Future<T> f){
          asPublisher(f).subscribe(sub);
     }
@@ -514,7 +546,7 @@ public static <T> Future<ListX<T>> sequencePresent(final CollectionX<Future<T>>
      * @param opts Maybes to Sequence
      * @return  Future with a List of values
      */
-    public static <T> Future<ReactiveSeq<T>> sequence(final Stream<Future<T>> opts) {
+    public static <T> Future<ReactiveSeq<T>> sequence(final java.util.stream.Stream<Future<T>> opts) {
         return AnyM.sequence(opts.map(Futures::anyM), future.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(VavrWitness::future);
@@ -703,11 +735,11 @@ public static <T> Future<T> narrow(final Future<? extends T> futureal) {
     }
 
     public static <T> Active<future,T> allTypeclasses(Future<T> future){
-        return Active.of(FutureKind.widen(future), Futures.Instances.definitions());
+        return Active.of(widen(future), Futures.Instances.definitions());
     }
     public static <T,W2,R> Nested<future,W2,R> mapM(Future<T> future, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Future<Higher<W2, R>> e = future.map(fn);
-        FutureKind<Higher<W2, R>> lk = FutureKind.widen(e);
+        FutureKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Futures.Instances.definitions(), defs);
     }
 
@@ -935,7 +967,7 @@ public static <T,R> MonadZero<future> monadZero(){
          */
         public static <T> MonadPlus<future> monadPlus(){
             Monoid<cyclops.async.Future<T>> mn = Monoids.firstSuccessfulFuture();
-            Monoid<FutureKind<T>> m = Monoid.of(FutureKind.widen(mn.zero()), (f, g)-> FutureKind.widen(
+            Monoid<FutureKind<T>> m = Monoid.of(widen(mn.zero()), (f, g)-> widen(
                     mn.apply(ToCyclopsReact.future(f), ToCyclopsReact.future(g))));
 
             Monoid<Higher<future,T>> m2= (Monoid)m;
@@ -1000,17 +1032,17 @@ public static <T> Comonad<future> comonad(){
         }
 
         private <T> FutureKind<T> of(T value){
-            return FutureKind.widen(Future.successful(value));
+            return widen(Future.successful(value));
         }
         private static <T,R> FutureKind<R> ap(FutureKind<Function< T, R>> lt, FutureKind<T> list){
-            return FutureKind.widen(ToCyclopsReact.future(lt).combine(ToCyclopsReact.future(list), (a, b)->a.apply(b)));
+            return widen(ToCyclopsReact.future(lt).combine(ToCyclopsReact.future(list), (a, b)->a.apply(b)));
 
         }
         private static <T,R> Higher<future,R> flatMap(Higher<future,T> lt, Function<? super T, ? extends  Higher<future,R>> fn){
-            return FutureKind.widen(FutureKind.narrow(lt).flatMap(fn.andThen(FutureKind::narrowK)));
+            return widen(FutureKind.narrow(lt).flatMap(fn.andThen(FutureKind::narrowK)));
         }
         private static <T,R> FutureKind<R> map(FutureKind<T> lt, Function<? super T, ? extends R> fn){
-            return FutureKind.widen(lt.map(fn));
+            return widen(lt.map(fn));
         }
 
 
@@ -1022,4 +1054,151 @@ private static <C2,T,R> Higher<C2, Higher<future, R>> traverseA(Applicative<C2>
 
     }
 
+    public static interface Nesteds{
+
+
+        public static <T> Nested<future,option,T> option(Future<Option<T>> type){
+            return Nested.of(widen(type.map(OptionKind::widen)),Instances.definitions(),Options.Instances.definitions());
+        }
+        public static <T> Nested<future,tryType,T> futureTry(Future<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<future,future,T> future(Future<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<future,lazy,T> lazy(Future<Lazy<T>> nested){
+            return Nested.of(widen(nested.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <L, R> Nested<future,Higher<VavrWitness.either,L>, R> either(Future<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<future,VavrWitness.queue,T> queue(Future<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)), Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <T> Nested<future,stream,T> stream(Future<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<future,list,T> list(Future<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<future,array,T> array(Future<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<future,vector,T> vector(Future<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<future,VavrWitness.set,T> set(Future<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<future,reactiveSeq,T> reactiveSeq(Future<ReactiveSeq<T>> nested){
+            FutureKind<ReactiveSeq<T>> x = widen(nested);
+            FutureKind<Higher<reactiveSeq,T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<future,maybe,T> maybe(Future<Maybe<T>> nested){
+            FutureKind<Maybe<T>> x = widen(nested);
+            FutureKind<Higher<maybe,T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<future,eval,T> eval(Future<Eval<T>> nested){
+            FutureKind<Eval<T>> x = widen(nested);
+            FutureKind<Higher<eval,T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<future,Witness.future,T> cyclopsFuture(Future<cyclops.async.Future<T>> nested){
+            FutureKind<cyclops.async.Future<T>> x = widen(nested);
+            FutureKind<Higher<Witness.future,T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<future,Higher<xor,S>, P> xor(Future<Xor<S, P>> nested){
+            FutureKind<Xor<S, P>> x = widen(nested);
+            FutureKind<Higher<Higher<xor,S>, P>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<future,Higher<reader,S>, T> reader(Future<Reader<S, T>> nested){
+            FutureKind<Reader<S, T>> x = widen(nested);
+            FutureKind<Higher<Higher<reader,S>, T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<future,Higher<Witness.tryType,S>, P> cyclopsTry(Future<cyclops.control.Try<P, S>> nested){
+            FutureKind<cyclops.control.Try<P, S>> x = widen(nested);
+            FutureKind<Higher<Higher<Witness.tryType,S>, P>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<future,optional,T> optional(Future<Optional<T>> nested){
+            FutureKind<Optional<T>> x = widen(nested);
+            FutureKind<Higher<optional,T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<future,completableFuture,T> completableFuture(Future<CompletableFuture<T>> nested){
+            FutureKind<CompletableFuture<T>> x = widen(nested);
+            FutureKind<Higher<completableFuture,T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<future,Witness.stream,T> javaStream(Future<java.util.stream.Stream<T>> nested){
+            FutureKind<java.util.stream.Stream<T>> x = widen(nested);
+            FutureKind<Higher<Witness.stream,T>> y = (FutureKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,future,T> reactiveSeq(ReactiveSeq<Future<T>> nested){
+                ReactiveSeq<Higher<future,T>> x = nested.map(FutureKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,future,T> maybe(Maybe<Future<T>> nested){
+                Maybe<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,future,T> eval(Eval<Future<T>> nested){
+                Eval<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,future,T> cyclopsFuture(cyclops.async.Future<Future<T>> nested){
+                cyclops.async.Future<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,future, P> xor(Xor<S, Future<P>> nested){
+                Xor<S, Higher<future,P>> x = nested.map(FutureKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,future, T> reader(Reader<S, Future<T>> nested){
+
+                Reader<S, Higher<future, T>>  x = nested.map(FutureKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,future, P> cyclopsTry(cyclops.control.Try<Future<P>, S> nested){
+                cyclops.control.Try<Higher<future,P>, S> x = nested.map(FutureKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,future,T> optional(Optional<Future<T>> nested){
+                Optional<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,future,T> completableFuture(CompletableFuture<Future<T>> nested){
+                CompletableFuture<Higher<future,T>> x = nested.thenApply(FutureKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,future,T> javaStream(java.util.stream.Stream<Future<T>> nested){
+                java.util.stream.Stream<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
+
+
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
index 35bff5fd..58dbcd69 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
@@ -1,8 +1,37 @@
 package cyclops.companion.vavr;
 
+import cyclops.monads.VavrWitness.*;
+import cyclops.monads.VavrWitness.list;
+import cyclops.monads.VavrWitness.stream;
+import cyclops.monads.VavrWitness.tryType;
+import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 
 import com.aol.cyclops.vavr.hkt.EitherKind;
 import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import com.aol.cyclops.vavr.hkt.LazyKind;
@@ -15,18 +44,11 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
-import cyclops.monads.AnyM;
-import cyclops.monads.VavrWitness;
-import cyclops.monads.VavrWitness.lazy;
-import cyclops.monads.Witness;
-import cyclops.monads.WitnessType;
+import cyclops.monads.*;
 import cyclops.monads.transformers.EvalT;
 import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -38,11 +60,20 @@
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
-import java.util.stream.Stream;
+
+
+import static com.aol.cyclops.vavr.hkt.LazyKind.widen;
 
 public class Lazys {
+
+    public static  <W1,T> Coproduct<W1,lazy,T> coproduct(Lazy<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+
     /**
      * Lifts a vavr Lazy into a cyclops LazyT monad transformer (involves an observables conversion to
      * cyclops Lazy types)
@@ -248,7 +279,7 @@ public static <T> Lazy<ListX<T>> sequencePresent(final CollectionX<Lazy<T>> opts
      * @param opts Maybes to Sequence
      * @return  Lazy with a List of values
      */
-    public static <T> Lazy<ReactiveSeq<T>> sequence(final Stream<Lazy<T>> opts) {
+    public static <T> Lazy<ReactiveSeq<T>> sequence(final java.util.stream.Stream<Lazy<T>> opts) {
         return FromCyclopsReact.eval(AnyM.sequence(opts.map(ToCyclopsReact::eval).map(AnyM::fromEval), Witness.eval.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(Witness::eval));
@@ -436,11 +467,11 @@ public static <T> Lazy<T> narrow(final Lazy<? extends T> futureal) {
         return (Lazy<T>) futureal;
     }
     public static <T> Active<lazy,T> allTypeclasses(Lazy<T> lazy){
-        return Active.of(LazyKind.widen(lazy), Lazys.Instances.definitions());
+        return Active.of(widen(lazy), Lazys.Instances.definitions());
     }
     public static <T,W2,R> Nested<lazy,W2,R> mapM(Lazy<T> lazy, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Lazy<Higher<W2, R>> e = lazy.map(fn);
-        LazyKind<Higher<W2, R>> lk = LazyKind.widen(e);
+        LazyKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Lazys.Instances.definitions(), defs);
     }
 
@@ -726,17 +757,17 @@ public static <T> Comonad<lazy> comonad(){
         }
 
         private <T> LazyKind<T> of(T value){
-            return LazyKind.widen(Lazy.of(()->value));
+            return widen(Lazy.of(()->value));
         }
         private static <T,R> LazyKind<R> ap(LazyKind<Function< T, R>> lt, LazyKind<T> lazy){
-            return LazyKind.widen(FromCyclopsReact.lazy(ToCyclopsReact.eval(lt.narrow()).combine(ToCyclopsReact.eval(lazy.narrow()), (a, b)->a.apply(b))));
+            return widen(FromCyclopsReact.lazy(ToCyclopsReact.eval(lt.narrow()).combine(ToCyclopsReact.eval(lazy.narrow()), (a, b)->a.apply(b))));
 
         }
         private static <T,R> Higher<lazy,R> flatMap(Higher<lazy,T> lt, Function<? super T, ? extends  Higher<lazy,R>> fn){
-            return LazyKind.widen(LazyKind.narrowEval(lt).flatMap(fn.andThen(LazyKind::narrowEval)));
+            return widen(LazyKind.narrowEval(lt).flatMap(fn.andThen(LazyKind::narrowEval)));
         }
         private static <T,R> LazyKind<R> map(LazyKind<T> lt, Function<? super T, ? extends R> fn){
-            return LazyKind.widen(LazyKind.narrow(lt).map(fn));
+            return widen(LazyKind.narrow(lt).map(fn));
         }
 
 
@@ -750,5 +781,151 @@ private static <C2,T,R> Higher<C2, Higher<lazy, R>> traverseA(Applicative<C2> ap
         }
 
     }
+    public static interface Nesteds{
+
+
+        public static <T> Nested<lazy,option,T> option(Lazy<Option<T>> type){
+            return Nested.of(widen(type.map(OptionKind::widen)),Instances.definitions(),Options.Instances.definitions());
+        }
+        public static <T> Nested<lazy,tryType,T> lazyTry(Lazy<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<lazy,VavrWitness.future,T> future(Lazy<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<lazy,lazy,T> lazy(Lazy<Lazy<T>> nested){
+            return Nested.of(widen(nested.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <L, R> Nested<lazy,Higher<VavrWitness.either,L>, R> either(Lazy<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<lazy,VavrWitness.queue,T> queue(Lazy<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)), Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <T> Nested<lazy,stream,T> stream(Lazy<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<lazy,list,T> list(Lazy<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<lazy,array,T> array(Lazy<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<lazy,vector,T> vector(Lazy<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<lazy,VavrWitness.set,T> set(Lazy<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<lazy,reactiveSeq,T> reactiveSeq(Lazy<ReactiveSeq<T>> nested){
+            LazyKind<ReactiveSeq<T>> x = widen(nested);
+            LazyKind<Higher<reactiveSeq,T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<lazy,maybe,T> maybe(Lazy<Maybe<T>> nested){
+            LazyKind<Maybe<T>> x = widen(nested);
+            LazyKind<Higher<maybe,T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<lazy,eval,T> eval(Lazy<Eval<T>> nested){
+            LazyKind<Eval<T>> x = widen(nested);
+            LazyKind<Higher<eval,T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<lazy,Witness.future,T> cyclopsFuture(Lazy<cyclops.async.Future<T>> nested){
+            LazyKind<cyclops.async.Future<T>> x = widen(nested);
+            LazyKind<Higher<Witness.future,T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<lazy,Higher<xor,S>, P> xor(Lazy<Xor<S, P>> nested){
+            LazyKind<Xor<S, P>> x = widen(nested);
+            LazyKind<Higher<Higher<xor,S>, P>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<lazy,Higher<reader,S>, T> reader(Lazy<Reader<S, T>> nested){
+            LazyKind<Reader<S, T>> x = widen(nested);
+            LazyKind<Higher<Higher<reader,S>, T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<lazy,Higher<Witness.tryType,S>, P> cyclopsTry(Lazy<cyclops.control.Try<P, S>> nested){
+            LazyKind<cyclops.control.Try<P, S>> x = widen(nested);
+            LazyKind<Higher<Higher<Witness.tryType,S>, P>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<lazy,optional,T> optional(Lazy<Optional<T>> nested){
+            LazyKind<Optional<T>> x = widen(nested);
+            LazyKind<Higher<optional,T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<lazy,completableFuture,T> completableLazy(Lazy<CompletableFuture<T>> nested){
+            LazyKind<CompletableFuture<T>> x = widen(nested);
+            LazyKind<Higher<completableFuture,T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<lazy,Witness.stream,T> javaStream(Lazy<java.util.stream.Stream<T>> nested){
+            LazyKind<java.util.stream.Stream<T>> x = widen(nested);
+            LazyKind<Higher<Witness.stream,T>> y = (LazyKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,lazy,T> reactiveSeq(ReactiveSeq<Lazy<T>> nested){
+                ReactiveSeq<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,lazy,T> maybe(Maybe<Lazy<T>> nested){
+                Maybe<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,lazy,T> eval(Eval<Lazy<T>> nested){
+                Eval<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,lazy,T> cyclopsFuture(cyclops.async.Future<Lazy<T>> nested){
+                cyclops.async.Future<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,lazy, P> xor(Xor<S, Lazy<P>> nested){
+                Xor<S, Higher<lazy,P>> x = nested.map(LazyKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,lazy, T> reader(Reader<S, Lazy<T>> nested){
+
+                Reader<S, Higher<lazy, T>>  x = nested.map(LazyKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,lazy, P> cyclopsTry(cyclops.control.Try<Lazy<P>, S> nested){
+                cyclops.control.Try<Higher<lazy,P>, S> x = nested.map(LazyKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,lazy,T> optional(Optional<Lazy<T>> nested){
+                Optional<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,lazy,T> completableLazy(CompletableFuture<Lazy<T>> nested){
+                CompletableFuture<Higher<lazy,T>> x = nested.thenApply(LazyKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,lazy,T> javaStream(java.util.stream.Stream<Lazy<T>> nested){
+                java.util.stream.Stream<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
+
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
index c55f5380..4a597039 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
@@ -1,43 +1,58 @@
 package cyclops.companion.vavr;
 
-import com.aol.cyclops.vavr.hkt.ArrayKind;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.collections.immutable.VectorX;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
 import cyclops.control.Maybe;
-import cyclops.monads.VavrWitness;
-import cyclops.monads.VavrWitness.list;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
 import cyclops.collections.vavr.VavrListX;
-import com.aol.cyclops.vavr.hkt.ListKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
-import cyclops.monads.AnyM;
-import cyclops.monads.WitnessType;
+import cyclops.monads.VavrWitness.either;
+import cyclops.monads.VavrWitness.future;
+import cyclops.monads.VavrWitness.list;
+import cyclops.monads.VavrWitness.tryType;
+import cyclops.monads.Witness.*;
 import cyclops.monads.transformers.ListT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
-import io.vavr.collection.Array;
-import io.vavr.collection.List;
+import io.vavr.Lazy;
+import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
+import io.vavr.control.Either;
+import io.vavr.control.Option;
+import io.vavr.control.Try;
 import lombok.experimental.UtilityClass;
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.*;
 
+import static com.aol.cyclops.vavr.hkt.ListKind.widen;
+
 
 public class Lists {
     public static <T,W extends WitnessType<W>> ListT<W, T> liftM(List<T> opt, W witness) {
         return ListT.ofList(witness.adapter().unit(VavrListX.ofAll(opt)));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,list,T> xorM(List<T> type){
+        return XorM.right(anyM(type));
+    }
     public static <T> AnyMSeq<list,T> anyM(List<T> option) {
         return AnyM.ofSeq(option, list.INSTANCE);
     }
@@ -312,11 +327,11 @@ public static <T, R1, R> List<R> forEach2(List<? extends T> value1,
     }
 
     public static <T> Active<list,T> allTypeclasses(List<T> array){
-        return Active.of(ListKind.widen(array), Lists.Instances.definitions());
+        return Active.of(widen(array), Lists.Instances.definitions());
     }
     public static <T,W2,R> Nested<list,W2,R> mapM(List<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         List<Higher<W2, R>> e = array.map(fn);
-        ListKind<Higher<W2, R>> lk = ListKind.widen(e);
+        ListKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Lists.Instances.definitions(), defs);
     }
     /**
@@ -525,7 +540,7 @@ public static <T,R> Monad<list> monad(){
          */
         public static <T,R> MonadZero<list> monadZero(){
             BiFunction<Higher<list,T>,Predicate<? super T>,Higher<list,T>> filter = Instances::filter;
-            Supplier<Higher<list, T>> zero = ()-> ListKind.widen(List.empty());
+            Supplier<Higher<list, T>> zero = ()-> widen(List.empty());
             return General.<list,T,R>monadZero(monad(), zero,filter);
         }
         /**
@@ -541,7 +556,7 @@ public static <T,R> MonadZero<list> monadZero(){
          * @return Type class for combining Lists by concatenation
          */
         public static <T> MonadPlus<list> monadPlus(){
-            Monoid<ListKind<T>> m = Monoid.of(ListKind.widen(List.<T>empty()), Instances::concat);
+            Monoid<ListKind<T>> m = Monoid.of(widen(List.<T>empty()), Instances::concat);
             Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -576,7 +591,7 @@ public static <T> MonadPlus<list> monadPlusK(Monoid<ListKind<T>> m){
         public static <C2,T> Traverse<list> traverse(){
             BiFunction<Applicative<C2>,ListKind<Higher<C2, T>>,Higher<C2, ListKind<T>>> sequenceFn = (ap, list) -> {
 
-                Higher<C2,ListKind<T>> identity = ap.unit(ListKind.widen(List.empty()));
+                Higher<C2,ListKind<T>> identity = ap.unit(widen(List.empty()));
 
                 BiFunction<Higher<C2,ListKind<T>>,Higher<C2,T>,Higher<C2,ListKind<T>>> combineToList =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> concat(a, ListKind.just(b))),acc,next);
 
@@ -615,34 +630,183 @@ public static <T> Foldable<list> foldable(){
         }
 
         private static  <T> ListKind<T> concat(ListKind<T> l1, ListKind<T> l2){
-            return ListKind.widen(l1.appendAll(l2));
+            return widen(l1.appendAll(l2));
         }
         private <T> ListKind<T> of(T value){
-            return ListKind.widen(List.of(value));
+            return widen(List.of(value));
         }
         private static <T,R> ListKind<R> ap(ListKind<Function< T, R>> lt, ListKind<T> list){
-            return ListKind.widen(lt.toReactiveSeq().zip(list,(a, b)->a.apply(b)));
+            return widen(lt.toReactiveSeq().zip(list,(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<list,R> flatMap(Higher<list,T> lt, Function<? super T, ? extends  Higher<list,R>> fn){
-            return ListKind.widen(ListKind.narrowK(lt).flatMap(fn.andThen(ListKind::narrowK)));
+            return widen(ListKind.narrowK(lt).flatMap(fn.andThen(ListKind::narrowK)));
         }
         private static <T,R> ListKind<R> map(ListKind<T> lt, Function<? super T, ? extends R> fn){
-            return ListKind.widen(lt.map(fn));
+            return widen(lt.map(fn));
         }
         private static <T> ListKind<T> filter(Higher<list,T> lt, Predicate<? super T> fn){
-            return ListKind.widen(ListKind.narrow(lt).filter(fn));
+            return widen(ListKind.narrow(lt).filter(fn));
         }
         public static Unfoldable<list> unfoldable(){
             return new Unfoldable<list>() {
                 @Override
                 public <R, T> Higher<list, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
-                    return ListKind.widen(ReactiveSeq.unfold(b,fn).collect(List.collector()));
+                    return widen(ReactiveSeq.unfold(b,fn).collect(List.collector()));
 
                 }
             };
         }
     }
 
+    public static  <W1,T> Coproduct<W1,list,T> coproduct(List<T> list, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(ListKind.widen(list)),def1, Instances.definitions());
+    }
+
+    public static interface Nesteds{
+
+
+        public static <T> Nested<list,option,T> option(List<Option<T>> type){
+            return Nested.of(widen(type.map(OptionKind::widen)),Instances.definitions(),Options.Instances.definitions());
+        }
+        public static <T> Nested<list,tryType,T> listTry(List<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<list,future,T> future(List<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<list,lazy,T> lazy(List<Lazy<T>> nested){
+            return Nested.of(widen(nested.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <L, R> Nested<list,Higher<either,L>, R> either(List<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<list,VavrWitness.stream,T> stream(List<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<list,VavrWitness.queue,T> queue(List<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)),Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <T> Nested<list,list,T> list(List<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)),Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<list,array,T> array(List<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<list,vector,T> vector(List<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<list,VavrWitness.set,T> set(List<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<list,reactiveSeq,T> reactiveSeq(List<ReactiveSeq<T>> nested){
+            ListKind<ReactiveSeq<T>> x = widen(nested);
+            ListKind<Higher<reactiveSeq,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<list,maybe,T> maybe(List<Maybe<T>> nested){
+            ListKind<Maybe<T>> x = widen(nested);
+            ListKind<Higher<maybe,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<list,eval,T> eval(List<Eval<T>> nested){
+            ListKind<Eval<T>> x = widen(nested);
+            ListKind<Higher<eval,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<list,Witness.future,T> cyclopsFuture(List<cyclops.async.Future<T>> nested){
+            ListKind<cyclops.async.Future<T>> x = widen(nested);
+            ListKind<Higher<Witness.future,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<list,Higher<xor,S>, P> xor(List<Xor<S, P>> nested){
+            ListKind<Xor<S, P>> x = widen(nested);
+            ListKind<Higher<Higher<xor,S>, P>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<list,Higher<reader,S>, T> reader(List<Reader<S, T>> nested){
+            ListKind<Reader<S, T>> x = widen(nested);
+            ListKind<Higher<Higher<reader,S>, T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<list,Higher<Witness.tryType,S>, P> cyclopsTry(List<cyclops.control.Try<P, S>> nested){
+            ListKind<cyclops.control.Try<P, S>> x = widen(nested);
+            ListKind<Higher<Higher<Witness.tryType,S>, P>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<list,optional,T> optional(List<Optional<T>> nested){
+            ListKind<Optional<T>> x = widen(nested);
+            ListKind<Higher<optional,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<list,completableFuture,T> completableFuture(List<CompletableFuture<T>> nested){
+            ListKind<CompletableFuture<T>> x = widen(nested);
+            ListKind<Higher<completableFuture,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<list,Witness.stream,T> javaStream(List<java.util.stream.Stream<T>> nested){
+            ListKind<java.util.stream.Stream<T>> x = widen(nested);
+            ListKind<Higher<Witness.stream,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,list,T> reactiveSeq(ReactiveSeq<List<T>> nested){
+                ReactiveSeq<Higher<list,T>> x = nested.map(ListKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,list,T> maybe(Maybe<List<T>> nested){
+                Maybe<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,list,T> eval(Eval<List<T>> nested){
+                Eval<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,list,T> cyclopsFuture(cyclops.async.Future<List<T>> nested){
+                cyclops.async.Future<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,list, P> xor(Xor<S, List<P>> nested){
+                Xor<S, Higher<list,P>> x = nested.map(ListKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,list, T> reader(Reader<S, List<T>> nested){
+
+                Reader<S, Higher<list, T>>  x = nested.map(ListKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,list, P> cyclopsTry(cyclops.control.Try<List<P>, S> nested){
+                cyclops.control.Try<Higher<list,P>, S> x = nested.map(ListKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,list,T> optional(Optional<List<T>> nested){
+                Optional<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,list,T> completableFuture(CompletableFuture<List<T>> nested){
+                CompletableFuture<Higher<list,T>> x = nested.thenApply(ListKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,list,T> javaStream(java.util.stream.Stream<List<T>> nested){
+                java.util.stream.Stream<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
 
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
index a2bbf884..023867fc 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
@@ -1,7 +1,33 @@
 package cyclops.companion.vavr;
 
+import cyclops.monads.VavrWitness.tryType;
+import io.vavr.Lazy;
+import io.vavr.collection.*;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.FutureKind;
 import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
@@ -19,12 +45,10 @@
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
 import cyclops.monads.WitnessType;
+import cyclops.monads.XorM;
 import cyclops.monads.transformers.OptionalT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -36,12 +60,16 @@
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
+import java.util.Optional;
 import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.OptionalLong;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
-import java.util.stream.Stream;
+
+
+import static com.aol.cyclops.vavr.hkt.OptionKind.widen;
 
 /**
  * Utility class for working with JDK Optionals
@@ -51,6 +79,12 @@
  */
 @UtilityClass
 public class Options {
+    public static  <W1,T> Coproduct<W1,option,T> coproduct(Option<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,option,T> xorM(Option<T> type){
+        return XorM.right(anyM(type));
+    }
     public static <T,W extends WitnessType<W>> OptionalT<W, T> liftM(Option<T> opt, W witness) {
         return OptionalT.of(witness.adapter().unit(opt.toJavaOptional()));
     }
@@ -397,7 +431,7 @@ public static <T> Option<ListX<T>> sequencePresent(final CollectionX<Option<T>>
      * @param opts Maybes to Sequence
      * @return  Option with a List of values
      */
-    public static <T> Option<ReactiveSeq<T>> sequence(final Stream<Option<T>> opts) {
+    public static <T> Option<ReactiveSeq<T>> sequence(final java.util.stream.Stream<Option<T>> opts) {
         return AnyM.sequence(opts.map(Options::anyM), option.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(VavrWitness::option);
@@ -585,11 +619,11 @@ public static <T> Option<T> narrow(final Option<? extends T> optional) {
         return (Option<T>) optional;
     }
     public static <T> Active<option,T> allTypeclasses(Option<T> option){
-        return Active.of(OptionKind.widen(option), Options.Instances.definitions());
+        return Active.of(widen(option), Options.Instances.definitions());
     }
     public static <T,W2,R> Nested<option,W2,R> mapM(Option<T> option, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Option<Higher<W2, R>> e = option.map(fn);
-        OptionKind<Higher<W2, R>> lk = OptionKind.widen(e);
+        OptionKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Options.Instances.definitions(), defs);
     }
     /**
@@ -879,17 +913,17 @@ public static <T> Comonad<option> comonad(){
         }
 
         private <T> OptionKind<T> of(T value){
-            return OptionKind.widen(Option.of(value));
+            return widen(Option.of(value));
         }
         private static <T,R> OptionKind<R> ap(OptionKind<Function< T, R>> lt, OptionKind<T> option){
-            return OptionKind.widen(FromCyclopsReact.option(ToCyclopsReact.maybe(lt).combine(ToCyclopsReact.maybe(option), (a, b)->a.apply(b))));
+            return widen(FromCyclopsReact.option(ToCyclopsReact.maybe(lt).combine(ToCyclopsReact.maybe(option), (a, b)->a.apply(b))));
 
         }
         private static <T,R> Higher<option,R> flatMap(Higher<option,T> lt, Function<? super T, ? extends  Higher<option,R>> fn){
-            return OptionKind.widen(OptionKind.narrow(lt).flatMap(fn.andThen(OptionKind::narrow)));
+            return widen(OptionKind.narrow(lt).flatMap(fn.andThen(OptionKind::narrow)));
         }
         private static <T,R> OptionKind<R> map(OptionKind<T> lt, Function<? super T, ? extends R> fn){
-            return OptionKind.widen(OptionKind.narrow(lt).map(fn));
+            return widen(OptionKind.narrow(lt).map(fn));
         }
 
 
@@ -898,11 +932,157 @@ private static <C2,T,R> Higher<C2, Higher<option, R>> traverseA(Applicative<C2>
 
             Option<T> option = OptionKind.narrow(ds);
             Higher<C2, OptionKind<R>> res = ToCyclopsReact.maybe(option).visit(some-> applicative.map(m-> OptionKind.of(m), fn.apply(some)),
-                    ()->applicative.unit(OptionKind.widen(OptionKind.<R>none())));
+                    ()->applicative.unit(widen(OptionKind.<R>none())));
 
             return OptionKind.widen2(res);
         }
 
     }
+    public static interface Nesteds{
+
+
+        public static <T> Nested<option,lazy,T> lazy(Option<Lazy<T>> type){
+            return Nested.of(widen(type.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <T> Nested<option,tryType,T> optionTry(Option<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<option,VavrWitness.future,T> future(Option<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<option,option,T> option(Option<Option<T>> nested){
+            return Nested.of(widen(nested.map(OptionKind::widen)),Instances.definitions(),Options.Instances.definitions());
+        }
+        public static <L, R> Nested<option,Higher<VavrWitness.either,L>, R> either(Option<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<option,VavrWitness.queue,T> queue(Option<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)), Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <T> Nested<option,VavrWitness.stream,T> stream(Option<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<option,VavrWitness.list,T> list(Option<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<option,array,T> array(Option<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<option,vector,T> vector(Option<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<option,VavrWitness.set,T> set(Option<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<option,reactiveSeq,T> reactiveSeq(Option<ReactiveSeq<T>> nested){
+            OptionKind<ReactiveSeq<T>> x = widen(nested);
+            OptionKind<Higher<reactiveSeq,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<option,maybe,T> maybe(Option<Maybe<T>> nested){
+            OptionKind<Maybe<T>> x = widen(nested);
+            OptionKind<Higher<maybe,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<option,eval,T> eval(Option<Eval<T>> nested){
+            OptionKind<Eval<T>> x = widen(nested);
+            OptionKind<Higher<eval,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<option,Witness.future,T> cyclopsFuture(Option<cyclops.async.Future<T>> nested){
+            OptionKind<cyclops.async.Future<T>> x = widen(nested);
+            OptionKind<Higher<Witness.future,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<option,Higher<xor,S>, P> xor(Option<Xor<S, P>> nested){
+            OptionKind<Xor<S, P>> x = widen(nested);
+            OptionKind<Higher<Higher<xor,S>, P>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<option,Higher<reader,S>, T> reader(Option<Reader<S, T>> nested){
+            OptionKind<Reader<S, T>> x = widen(nested);
+            OptionKind<Higher<Higher<reader,S>, T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<option,Higher<Witness.tryType,S>, P> cyclopsTry(Option<cyclops.control.Try<P, S>> nested){
+            OptionKind<cyclops.control.Try<P, S>> x = widen(nested);
+            OptionKind<Higher<Higher<Witness.tryType,S>, P>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<option,optional,T> optional(Option<Optional<T>> nested){
+            OptionKind<Optional<T>> x = widen(nested);
+            OptionKind<Higher<optional,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<option,completableFuture,T> completableOption(Option<CompletableFuture<T>> nested){
+            OptionKind<CompletableFuture<T>> x = widen(nested);
+            OptionKind<Higher<completableFuture,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<option,Witness.stream,T> javaStream(Option<java.util.stream.Stream<T>> nested){
+            OptionKind<java.util.stream.Stream<T>> x = widen(nested);
+            OptionKind<Higher<Witness.stream,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,option,T> reactiveSeq(ReactiveSeq<Option<T>> nested){
+                ReactiveSeq<Higher<option,T>> x = nested.map(OptionKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,option,T> maybe(Maybe<Option<T>> nested){
+                Maybe<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,option,T> eval(Eval<Option<T>> nested){
+                Eval<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,option,T> cyclopsFuture(cyclops.async.Future<Option<T>> nested){
+                cyclops.async.Future<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,option, P> xor(Xor<S, Option<P>> nested){
+                Xor<S, Higher<option,P>> x = nested.map(OptionKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,option, T> reader(Reader<S, Option<T>> nested){
+
+                Reader<S, Higher<option, T>>  x = nested.map(OptionKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,option, P> cyclopsTry(cyclops.control.Try<Option<P>, S> nested){
+                cyclops.control.Try<Higher<option,P>, S> x = nested.map(OptionKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,option,T> optional(Optional<Option<T>> nested){
+                Optional<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,option,T> completableOption(CompletableFuture<Option<T>> nested){
+                CompletableFuture<Higher<option,T>> x = nested.thenApply(OptionKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,option,T> javaStream(java.util.stream.Stream<Option<T>> nested){
+                java.util.stream.Stream<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
+
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
index 7eaa7837..f9c9ce75 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
@@ -1,7 +1,34 @@
 package cyclops.companion.vavr;
 
+import cyclops.monads.VavrWitness.tryType;
+import io.vavr.Lazy;
+import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.ListKind;
 import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.queue;
@@ -12,11 +39,10 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.WitnessType;
+import cyclops.monads.XorM;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -29,15 +55,23 @@
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 
+import static com.aol.cyclops.vavr.hkt.QueueKind.widen;
+
 
 public class Queues {
 
+    public static  <W1,T> Coproduct<W1,queue,T> coproduct(Queue<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,queue,T> xorM(Queue<T> type){
+        return XorM.right(anyM(type));
+    }
 
-   
     public static <T> AnyMSeq<queue,T> anyM(Queue<T> option) {
         return AnyM.ofSeq(option, queue.INSTANCE);
     }
@@ -311,11 +345,11 @@ public static <T, R1, R> Queue<R> forEach2(Queue<? extends T> value1,
         });
     }
     public static <T> Active<queue,T> allTypeclasses(Queue<T> array){
-        return Active.of(QueueKind.widen(array), Queues.Instances.definitions());
+        return Active.of(widen(array), Queues.Instances.definitions());
     }
     public static <T,W2,R> Nested<queue,W2,R> mapM(Queue<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Queue<Higher<W2, R>> e = array.map(fn);
-        QueueKind<Higher<W2, R>> lk = QueueKind.widen(e);
+        QueueKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Queues.Instances.definitions(), defs);
     }
     /**
@@ -525,7 +559,7 @@ public static <T,R> Monad<queue> monad(){
          */
         public static <T,R> MonadZero<queue> monadZero(){
 
-            return General.monadZero(monad(), QueueKind.widen(Queue.empty()));
+            return General.monadZero(monad(), widen(Queue.empty()));
         }
         /**
          * <pre>
@@ -540,7 +574,7 @@ public static <T,R> MonadZero<queue> monadZero(){
          * @return Type class for combining Queues by concatenation
          */
         public static <T> MonadPlus<queue> monadPlus(){
-            Monoid<QueueKind<T>> m = Monoid.of(QueueKind.widen(Queue.empty()), Instances::concat);
+            Monoid<QueueKind<T>> m = Monoid.of(widen(Queue.empty()), Instances::concat);
             Monoid<Higher<queue,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -560,7 +594,11 @@ public static <T> MonadPlus<queue> monadPlus(){
          * @param m Monoid to use for combining Queues
          * @return Type class for combining Queues
          */
-        public static <T> MonadPlus<queue> monadPlus(Monoid<QueueKind<T>> m){
+        public static <T> MonadPlus<queue> monadPlus(Monoid<Higher<queue,T>> m){
+            Monoid<Higher<queue,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<queue> monadPlusK(Monoid<QueueKind<T>> m){
             Monoid<Higher<queue,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -572,12 +610,12 @@ public static <C2,T> Traverse<queue> traverse(){
 
             BiFunction<Applicative<C2>,QueueKind<Higher<C2, T>>,Higher<C2, QueueKind<T>>> sequenceFn = (ap, list) -> {
 
-                Higher<C2,QueueKind<T>> identity = ap.unit(QueueKind.widen(Queue.empty()));
+                Higher<C2,QueueKind<T>> identity = ap.unit(widen(Queue.empty()));
 
-                BiFunction<Higher<C2,QueueKind<T>>,Higher<C2,T>,Higher<C2,QueueKind<T>>> combineToQueue =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> QueueKind.widen(QueueKind.narrow(a).append(b))),
+                BiFunction<Higher<C2,QueueKind<T>>,Higher<C2,T>,Higher<C2,QueueKind<T>>> combineToQueue =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(QueueKind.narrow(a).append(b))),
                         acc,next);
 
-                BinaryOperator<Higher<C2,QueueKind<T>>> combineQueues = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> QueueKind.widen(QueueKind.narrow(l1).appendAll(l2.narrow()))),a,b); ;
+                BinaryOperator<Higher<C2,QueueKind<T>>> combineQueues = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> widen(QueueKind.narrow(l1).appendAll(l2.narrow()))),a,b); ;
 
                 return ReactiveSeq.fromIterable(QueueKind.narrow(list))
                         .reduce(identity,
@@ -614,24 +652,24 @@ public static <T> Foldable<queue> foldable(){
 
         private static  <T> QueueKind<T> concat(QueueKind<T> l1, QueueKind<T> l2){
 
-            return QueueKind.widen(l1.appendAll(QueueKind.narrow(l2)));
+            return widen(l1.appendAll(QueueKind.narrow(l2)));
 
         }
 
         private static <T,R> QueueKind<R> ap(QueueKind<Function< T, R>> lt, QueueKind<T> list){
-            return QueueKind.widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toQueue());
+            return widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt.narrow()).zip(list.narrow(), (a, b)->a.apply(b))).toQueue());
         }
         private static <T,R> Higher<queue,R> flatMap(Higher<queue,T> lt, Function<? super T, ? extends  Higher<queue,R>> fn){
-            return QueueKind.widen(QueueKind.narrow(lt).flatMap(fn.andThen(QueueKind::narrow)));
+            return widen(QueueKind.narrow(lt).flatMap(fn.andThen(QueueKind::narrow)));
         }
         private static <T,R> QueueKind<R> map(QueueKind<T> lt, Function<? super T, ? extends R> fn){
-            return QueueKind.widen(QueueKind.narrow(lt).map(in->fn.apply(in)));
+            return widen(QueueKind.narrow(lt).map(in->fn.apply(in)));
         }
         public static Unfoldable<queue> unfoldable(){
             return new Unfoldable<queue>() {
                 @Override
                 public <R, T> Higher<queue, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
-                    return QueueKind.widen(ReactiveSeq.unfold(b,fn).collect(Queue.collector()));
+                    return widen(ReactiveSeq.unfold(b,fn).collect(Queue.collector()));
 
                 }
             };
@@ -639,5 +677,147 @@ public <R, T> Higher<queue, R> unfold(T b, Function<? super T, Optional<Tuple2<R
     }
 
 
+    public static interface Nesteds{
+
+
+        public static <T> Nested<queue,lazy,T> lazy(Queue<Lazy<T>> type){
+            return Nested.of(widen(type.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <T> Nested<queue,tryType,T> queueTry(Queue<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<queue,VavrWitness.future,T> future(Queue<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<queue,queue,T> queue(Queue<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)),Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <L, R> Nested<queue,Higher<VavrWitness.either,L>, R> either(Queue<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<queue,VavrWitness.stream,T> stream(Queue<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<queue,VavrWitness.list,T> list(Queue<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<queue,array,T> array(Queue<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<queue,vector,T> vector(Queue<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<queue,VavrWitness.set,T> set(Queue<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<queue,reactiveSeq,T> reactiveSeq(Queue<ReactiveSeq<T>> nested){
+            QueueKind<ReactiveSeq<T>> x = widen(nested);
+            QueueKind<Higher<reactiveSeq,T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<queue,maybe,T> maybe(Queue<Maybe<T>> nested){
+            QueueKind<Maybe<T>> x = widen(nested);
+            QueueKind<Higher<maybe,T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<queue,eval,T> eval(Queue<Eval<T>> nested){
+            QueueKind<Eval<T>> x = widen(nested);
+            QueueKind<Higher<eval,T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<queue,Witness.future,T> cyclopsFuture(Queue<cyclops.async.Future<T>> nested){
+            QueueKind<cyclops.async.Future<T>> x = widen(nested);
+            QueueKind<Higher<Witness.future,T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<queue,Higher<xor,S>, P> xor(Queue<Xor<S, P>> nested){
+            QueueKind<Xor<S, P>> x = widen(nested);
+            QueueKind<Higher<Higher<xor,S>, P>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<queue,Higher<reader,S>, T> reader(Queue<Reader<S, T>> nested){
+            QueueKind<Reader<S, T>> x = widen(nested);
+            QueueKind<Higher<Higher<reader,S>, T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<queue,Higher<Witness.tryType,S>, P> cyclopsTry(Queue<cyclops.control.Try<P, S>> nested){
+            QueueKind<cyclops.control.Try<P, S>> x = widen(nested);
+            QueueKind<Higher<Higher<Witness.tryType,S>, P>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<queue,optional,T> queueal(Queue<Optional<T>> nested){
+            QueueKind<Optional<T>> x = widen(nested);
+            QueueKind<Higher<optional,T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<queue,completableFuture,T> completableQueue(Queue<CompletableFuture<T>> nested){
+            QueueKind<CompletableFuture<T>> x = widen(nested);
+            QueueKind<Higher<completableFuture,T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<queue,Witness.stream,T> javaStream(Queue<java.util.stream.Stream<T>> nested){
+            QueueKind<java.util.stream.Stream<T>> x = widen(nested);
+            QueueKind<Higher<Witness.stream,T>> y = (QueueKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,queue,T> reactiveSeq(ReactiveSeq<Queue<T>> nested){
+                ReactiveSeq<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,queue,T> maybe(Maybe<Queue<T>> nested){
+                Maybe<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,queue,T> eval(Eval<Queue<T>> nested){
+                Eval<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,queue,T> cyclopsFuture(cyclops.async.Future<Queue<T>> nested){
+                cyclops.async.Future<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,queue, P> xor(Xor<S, Queue<P>> nested){
+                Xor<S, Higher<queue,P>> x = nested.map(QueueKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,queue, T> reader(Reader<S, Queue<T>> nested){
+
+                Reader<S, Higher<queue, T>>  x = nested.map(QueueKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,queue, P> cyclopsTry(cyclops.control.Try<Queue<P>, S> nested){
+                cyclops.control.Try<Higher<queue,P>, S> x = nested.map(QueueKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,queue,T> queueal(Optional<Queue<T>> nested){
+                Optional<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,queue,T> completableQueue(CompletableFuture<Queue<T>> nested){
+                CompletableFuture<Higher<queue,T>> x = nested.thenApply(QueueKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,queue,T> javaStream(java.util.stream.Stream<Queue<T>> nested){
+                java.util.stream.Stream<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
index 31e64bc7..8acc8b13 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
@@ -1,22 +1,49 @@
 package cyclops.companion.vavr;
 
+import cyclops.monads.VavrWitness.queue;
+import io.vavr.Lazy;
+import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.SetKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
 
 import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.hashSet;
 import cyclops.monads.VavrWitness.set;
 import cyclops.monads.WitnessType;
 
+import cyclops.monads.XorM;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -29,12 +56,21 @@
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.*;
 
+import static com.aol.cyclops.vavr.hkt.SetKind.widen;
+
 
 public class Sets {
 
-    public static <T> AnyMSeq<set,T> anyM(Set<T> option) {
+    public static  <W1,T> Coproduct<W1,set,T> coproduct(HashSet<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,set,T> xorM(HashSet<T> type){
+        return XorM.right(anyM(type));
+    }
+    public static <T> AnyMSeq<set,T> anyM(HashSet<T> option) {
         return AnyM.ofSeq(option, set.INSTANCE);
     }
     /**
@@ -307,12 +343,12 @@ public static <T, R1, R> Set<R> forEach2(Set<? extends T> value1,
         });
     }
 
-    public static <T> Active<set,T> allTypeclasses(Set<T> array){
-        return Active.of(SetKind.widen(array), Sets.Instances.definitions());
+    public static <T> Active<set,T> allTypeclasses(HashSet<T> array){
+        return Active.of(widen(array), Sets.Instances.definitions());
     }
-    public static <T,W2,R> Nested<set,W2,R> mapM(Set<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
-        Set<Higher<W2, R>> e = array.map(fn);
-        SetKind<Higher<W2, R>> lk = SetKind.widen(e);
+    public static <T,W2,R> Nested<set,W2,R> mapM(HashSet<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        HashSet<Higher<W2, R>> e = array.map(fn);
+        SetKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Sets.Instances.definitions(), defs);
     }
     /**
@@ -521,7 +557,7 @@ public static <T,R> Monad<set> monad(){
          */
         public static <T,R> MonadZero<set> monadZero(){
             BiFunction<Higher<set,T>,Predicate<? super T>,Higher<set,T>> filter = Instances::filter;
-            Supplier<Higher<set, T>> zero = ()-> SetKind.widen(HashSet.empty());
+            Supplier<Higher<set, T>> zero = ()-> widen(HashSet.empty());
             return General.<set,T,R>monadZero(monad(), zero,filter);
         }
         /**
@@ -537,7 +573,7 @@ public static <T,R> MonadZero<set> monadZero(){
          * @return Type class for combining Sets by concatenation
          */
         public static <T> MonadPlus<set> monadPlus(){
-            Monoid<SetKind<T>> m = Monoid.of(SetKind.widen(HashSet.<T>empty()), Instances::concat);
+            Monoid<SetKind<T>> m = Monoid.of(widen(HashSet.<T>empty()), Instances::concat);
             Monoid<Higher<set,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -572,7 +608,7 @@ public static <T> MonadPlus<set> monadPlusK(Monoid<SetKind<T>> m){
         public static <C2,T> Traverse<set> traverse(){
             BiFunction<Applicative<C2>,SetKind<Higher<C2, T>>,Higher<C2, SetKind<T>>> sequenceFn = (ap, set) -> {
 
-                Higher<C2,SetKind<T>> identity = ap.unit(SetKind.widen(HashSet.empty()));
+                Higher<C2,SetKind<T>> identity = ap.unit(widen(HashSet.empty()));
 
                 BiFunction<Higher<C2,SetKind<T>>,Higher<C2,T>,Higher<C2,SetKind<T>>> combineToSet =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> concat(a, SetKind.just(b))),acc,next);
 
@@ -611,34 +647,175 @@ public static <T> Foldable<set> foldable(){
         }
 
         private static  <T> SetKind<T> concat(SetKind<T> l1, SetKind<T> l2){
-            return SetKind.widen(l1.addAll(l2));
+            return widen(l1.addAll(l2));
         }
         private <T> SetKind<T> of(T value){
-            return SetKind.widen(HashSet.of(value));
+            return widen(HashSet.of(value));
         }
         private static <T,R> SetKind<R> ap(SetKind<Function< T, R>> lt, SetKind<T> set){
-            return SetKind.widen(lt.toReactiveSeq().zip(set,(a, b)->a.apply(b)));
+            return widen(lt.toReactiveSeq().zip(set,(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<set,R> flatMap(Higher<set,T> lt, Function<? super T, ? extends  Higher<set,R>> fn){
-            return SetKind.widen(SetKind.narrowK(lt).flatMap(fn.andThen(SetKind::narrowK)));
+            return widen(SetKind.narrowK(lt).flatMap(fn.andThen(SetKind::narrowK)));
         }
         private static <T,R> SetKind<R> map(SetKind<T> lt, Function<? super T, ? extends R> fn){
-            return SetKind.widen(lt.map(fn));
+            return widen(lt.map(fn));
         }
         private static <T> SetKind<T> filter(Higher<set,T> lt, Predicate<? super T> fn){
-            return SetKind.widen(SetKind.narrow(lt).filter(fn));
+            return widen(SetKind.narrow(lt).filter(fn));
         }
         public static Unfoldable<set> unfoldable(){
             return new Unfoldable<set>() {
                 @Override
                 public <R, T> Higher<set, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
-                    return SetKind.widen(ReactiveSeq.unfold(b,fn).collect(HashSet.collector()));
+                    return widen(ReactiveSeq.unfold(b,fn).collect(HashSet.collector()));
 
                 }
             };
         }
     }
+    public static interface Nesteds{
+
+
+        public static <T> Nested<set,lazy,T> lazy(HashSet<Lazy<T>> type){
+            return Nested.of(widen(type.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <T> Nested<set,VavrWitness.tryType,T> setTry(HashSet<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<set,VavrWitness.future,T> future(HashSet<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<set,queue,T>  queue(HashSet<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)),Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <L, R> Nested<set,Higher<VavrWitness.either,L>, R> either(HashSet<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<set,VavrWitness.stream,T> stream(HashSet<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<set,VavrWitness.list,T> list(HashSet<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<set,array,T> array(HashSet<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<set,vector,T> vector(HashSet<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<set,VavrWitness.set,T> set(HashSet<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<set,reactiveSeq,T> reactiveSeq(HashSet<ReactiveSeq<T>> nested){
+            SetKind<ReactiveSeq<T>> x = widen(nested);
+            SetKind<Higher<reactiveSeq,T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
 
+        public static <T> Nested<set,maybe,T> maybe(HashSet<Maybe<T>> nested){
+            SetKind<Maybe<T>> x = widen(nested);
+            SetKind<Higher<maybe,T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<set,eval,T> eval(HashSet<Eval<T>> nested){
+            SetKind<Eval<T>> x = widen(nested);
+            SetKind<Higher<eval,T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<set,Witness.future,T> cyclopsFuture(HashSet<cyclops.async.Future<T>> nested){
+            SetKind<cyclops.async.Future<T>> x = widen(nested);
+            SetKind<Higher<Witness.future,T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<set,Higher<xor,S>, P> xor(HashSet<Xor<S, P>> nested){
+            SetKind<Xor<S, P>> x = widen(nested);
+            SetKind<Higher<Higher<xor,S>, P>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<set,Higher<reader,S>, T> reader(HashSet<Reader<S, T>> nested){
+            SetKind<Reader<S, T>> x = widen(nested);
+            SetKind<Higher<Higher<reader,S>, T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<set,Higher<Witness.tryType,S>, P> cyclopsTry(HashSet<cyclops.control.Try<P, S>> nested){
+            SetKind<cyclops.control.Try<P, S>> x = widen(nested);
+            SetKind<Higher<Higher<Witness.tryType,S>, P>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<set,optional,T> setal(HashSet<Optional<T>> nested){
+            SetKind<Optional<T>> x = widen(nested);
+            SetKind<Higher<optional,T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<set,completableFuture,T> completableSet(HashSet<CompletableFuture<T>> nested){
+            SetKind<CompletableFuture<T>> x = widen(nested);
+            SetKind<Higher<completableFuture,T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<set,Witness.stream,T> javaStream(HashSet<java.util.stream.Stream<T>> nested){
+            SetKind<java.util.stream.Stream<T>> x = widen(nested);
+            SetKind<Higher<Witness.stream,T>> y = (SetKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,set,T> reactiveSeq(ReactiveSeq<HashSet<T>> nested){
+                ReactiveSeq<Higher<set,T>> x = nested.map(SetKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,set,T> maybe(Maybe<HashSet<T>> nested){
+                Maybe<Higher<set,T>> x = nested.map(SetKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,set,T> eval(Eval<HashSet<T>> nested){
+                Eval<Higher<set,T>> x = nested.map(SetKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,set,T> cyclopsFuture(cyclops.async.Future<HashSet<T>> nested){
+                cyclops.async.Future<Higher<set,T>> x = nested.map(SetKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,set, P> xor(Xor<S, HashSet<P>> nested){
+                Xor<S, Higher<set,P>> x = nested.map(SetKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,set, T> reader(Reader<S, HashSet<T>> nested){
+
+                Reader<S, Higher<set, T>>  x = nested.map(SetKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,set, P> cyclopsTry(cyclops.control.Try<HashSet<P>, S> nested){
+                cyclops.control.Try<Higher<set,P>, S> x = nested.map(SetKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,set,T> setal(Optional<HashSet<T>> nested){
+                Optional<Higher<set,T>> x = nested.map(SetKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,set,T> completableSet(CompletableFuture<HashSet<T>> nested){
+                CompletableFuture<Higher<set,T>> x = nested.thenApply(SetKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,set,T> javaStream(java.util.stream.Stream<HashSet<T>> nested){
+                java.util.stream.Stream<Higher<set,T>> x = nested.map(SetKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
 
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index 89a87b15..bad65203 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -1,7 +1,31 @@
 package cyclops.companion.vavr;
 
+import io.vavr.collection.*;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.ListKind;
 import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.stream;
@@ -12,11 +36,10 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.WitnessType;
+import cyclops.monads.XorM;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -33,10 +56,16 @@
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 
-
-public class Streams {
+import static com.aol.cyclops.vavr.hkt.StreamKind.widen;
 
 
+public class Streams {
+    public static  <W1,T> Coproduct<W1,stream,T> coproduct(Stream<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,stream,T> xorM(Stream<T> type){
+        return XorM.right(anyM(type));
+    }
    
     public static <T> AnyMSeq<stream,T> anyM(Stream<T> option) {
         return AnyM.ofSeq(option, stream.INSTANCE);
@@ -311,11 +340,11 @@ public static <T, R1, R> Stream<R> forEach2(Stream<? extends T> value1,
         });
     }
     public static <T> Active<stream,T> allTypeclasses(Stream<T> array){
-        return Active.of(StreamKind.widen(array), Streams.Instances.definitions());
+        return Active.of(widen(array), Streams.Instances.definitions());
     }
     public static <T,W2,R> Nested<stream,W2,R> mapM(Stream<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Stream<Higher<W2, R>> e = array.map(fn);
-        StreamKind<Higher<W2, R>> lk = StreamKind.widen(e);
+        StreamKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Streams.Instances.definitions(), defs);
     }
     /**
@@ -526,7 +555,7 @@ public static <T,R> Monad<stream> monad(){
          */
         public static <T,R> MonadZero<stream> monadZero(){
 
-            return General.monadZero(monad(), StreamKind.widen(Stream.empty()));
+            return General.monadZero(monad(), widen(Stream.empty()));
         }
         /**
          * <pre>
@@ -541,7 +570,7 @@ public static <T,R> MonadZero<stream> monadZero(){
          * @return Type class for combining Streams by concatenation
          */
         public static <T> MonadPlus<stream> monadPlus(){
-            Monoid<StreamKind<T>> m = Monoid.of(StreamKind.widen(Stream.empty()), Instances::concat);
+            Monoid<StreamKind<T>> m = Monoid.of(widen(Stream.empty()), Instances::concat);
             Monoid<Higher<stream,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -577,12 +606,12 @@ public static <C2,T> Traverse<stream> traverse(){
 
             BiFunction<Applicative<C2>,StreamKind<Higher<C2, T>>,Higher<C2, StreamKind<T>>> sequenceFn = (ap, list) -> {
 
-                Higher<C2,StreamKind<T>> identity = ap.unit(StreamKind.widen(Stream.empty()));
+                Higher<C2,StreamKind<T>> identity = ap.unit(widen(Stream.empty()));
 
-                BiFunction<Higher<C2,StreamKind<T>>,Higher<C2,T>,Higher<C2,StreamKind<T>>> combineToStream =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> StreamKind.widen(StreamKind.narrow(a).append(b))),
+                BiFunction<Higher<C2,StreamKind<T>>,Higher<C2,T>,Higher<C2,StreamKind<T>>> combineToStream =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(StreamKind.narrow(a).append(b))),
                         acc,next);
 
-                BinaryOperator<Higher<C2,StreamKind<T>>> combineStreams = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> StreamKind.widen(StreamKind.narrow(l1).appendAll(l2))),a,b); ;
+                BinaryOperator<Higher<C2,StreamKind<T>>> combineStreams = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> widen(StreamKind.narrow(l1).appendAll(l2))),a,b); ;
 
                 return ReactiveSeq.fromIterable(StreamKind.narrow(list))
                         .reduce(identity,
@@ -619,24 +648,24 @@ public static <T> Foldable<stream> foldable(){
 
         private static  <T> StreamKind<T> concat(StreamKind<T> l1, StreamKind<T> l2){
 
-            return StreamKind.widen(l1.appendAll(StreamKind.narrow(l2)));
+            return widen(l1.appendAll(StreamKind.narrow(l2)));
 
         }
 
         private static <T,R> StreamKind<R> ap(StreamKind<Function< T, R>> lt, StreamKind<T> list){
-            return StreamKind.widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt).zip(list, (a, b)->a.apply(b))).toStream());
+            return widen(FromCyclopsReact.fromStream(ReactiveSeq.fromIterable(lt).zip(list, (a, b)->a.apply(b))).toStream());
         }
         private static <T,R> Higher<stream,R> flatMap(Higher<stream,T> lt, Function<? super T, ? extends  Higher<stream,R>> fn){
-            return StreamKind.widen(StreamKind.narrow(lt).flatMap(fn.andThen(StreamKind::narrow)));
+            return widen(StreamKind.narrow(lt).flatMap(fn.andThen(StreamKind::narrow)));
         }
         private static <T,R> StreamKind<R> map(StreamKind<T> lt, Function<? super T, ? extends R> fn){
-            return StreamKind.widen(StreamKind.narrow(lt).map(in->fn.apply(in)));
+            return widen(StreamKind.narrow(lt).map(in->fn.apply(in)));
         }
         public static Unfoldable<stream> unfoldable(){
             return new Unfoldable<stream>() {
                 @Override
                 public <R, T> Higher<stream, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
-                    return StreamKind.widen(ReactiveSeq.unfold(b,fn).collect(Stream.collector()));
+                    return widen(ReactiveSeq.unfold(b,fn).collect(Stream.collector()));
 
                 }
             };
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
index 8a4d2cde..85961dcc 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
@@ -1,10 +1,34 @@
 package cyclops.companion.vavr;
 
 
+import io.vavr.collection.*;
+import io.vavr.control.*;
+import com.aol.cyclops.vavr.hkt.*;
+import cyclops.VavrConverters;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.conversion.vavr.FromCyclopsReact;
+import cyclops.conversion.vavr.FromJDK;
+import cyclops.conversion.vavr.FromJooqLambda;
+import cyclops.monads.*;
+import cyclops.monads.VavrWitness.*;
+import com.aol.cyclops2.hkt.Higher;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.TryKind;
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.companion.Monoids;
 import cyclops.control.Maybe;
+import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
@@ -18,11 +42,10 @@
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
 import cyclops.monads.VavrWitness.tryType;
+import cyclops.monads.WitnessType;
+import cyclops.monads.XorM;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -38,6 +61,8 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+import static com.aol.cyclops.vavr.hkt.TryKind.widen;
+
 /**
  * Utility class for working with JDK Tryals
  *
@@ -47,6 +72,12 @@
 @UtilityClass
 public class Trys {
 
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,tryType,T> xorM(Try<T> type){
+        return XorM.right(anyM(type));
+    }
+    public static  <W1,T> Coproduct<W1,tryType,T> coproduct(Try<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
     public static <T> AnyMValue<tryType,T> anyM(Try<T> tryType) {
         return AnyM.ofValue(tryType, VavrWitness.tryType.INSTANCE);
     }
@@ -567,11 +598,11 @@ public static <T> Try<T> narrow(final Try<? extends T> tryTypeal) {
     }
 
     public static <T> Active<tryType,T> allTypeclasses(Try<T> tryType){
-        return Active.of(TryKind.widen(tryType), Trys.Instances.definitions());
+        return Active.of(widen(tryType), Trys.Instances.definitions());
     }
     public static <T,W2,R> Nested<tryType,W2,R> mapM(Try<T> tryType, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         Try<Higher<W2, R>> e = tryType.map(fn);
-        TryKind<Higher<W2, R>> lk = TryKind.widen(e);
+        TryKind<Higher<W2, R>> lk = widen(e);
         return Nested.of(lk, Trys.Instances.definitions(), defs);
     }
 
@@ -799,7 +830,7 @@ public static <T,R> MonadZero<tryType> monadZero(){
          */
         public static <T> MonadPlus<tryType> monadPlus(){
             Monoid<cyclops.control.Try<T,Throwable>> mn = Monoids.firstTrySuccess(new NoSuchElementException());
-            Monoid<TryKind<T>> m = Monoid.of(TryKind.widen(mn.zero()), (f, g)-> TryKind.widen(
+            Monoid<TryKind<T>> m = Monoid.of(widen(mn.zero()), (f, g)-> widen(
                     mn.apply(ToCyclopsReact.toTry(f), ToCyclopsReact.toTry(g))));
 
             Monoid<Higher<tryType,T>> m2= (Monoid)m;
@@ -860,17 +891,17 @@ public static <T> Comonad<tryType> comonad(){
         }
 
         private <T> TryKind<T> of(T value){
-            return TryKind.widen(Try.success(value));
+            return widen(Try.success(value));
         }
         private static <T,R> TryKind<R> ap(TryKind<Function< T, R>> lt, TryKind<T> list){
-            return TryKind.widen(ToCyclopsReact.toTry(lt).combine(ToCyclopsReact.toTry(list), (a, b)->a.apply(b)));
+            return widen(ToCyclopsReact.toTry(lt).combine(ToCyclopsReact.toTry(list), (a, b)->a.apply(b)));
 
         }
         private static <T,R> Higher<tryType,R> flatMap(Higher<tryType,T> lt, Function<? super T, ? extends  Higher<tryType,R>> fn){
-            return TryKind.widen(TryKind.narrow(lt).flatMap(fn.andThen(TryKind::narrowK)));
+            return widen(TryKind.narrow(lt).flatMap(fn.andThen(TryKind::narrowK)));
         }
         private static <T,R> TryKind<R> map(TryKind<T> lt, Function<? super T, ? extends R> fn){
-            return TryKind.widen(lt.map(fn));
+            return widen(lt.map(fn));
         }
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
index a5bc1c91..6c674d9d 100644
--- a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
+++ b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
@@ -270,12 +270,28 @@ public FunctionalAdapter<lazy> adapter() {
         }
 
     }
-    public static enum set implements WitnessType<set> {
+    public static enum set implements TraversableWitness<set> {
         INSTANCE;
 
         @Override
         public FunctionalAdapter<set> adapter() {
-            return null;
+            return new TraversableAdapter(INSTANCE){
+
+                @Override
+                public Traversable traversableFromIterable(Iterable value) {
+                    return HashSet.ofAll(value);
+                }
+
+                @Override
+                public Traversable singletonTraversable(Object value) {
+                    return HashSet.of(value);
+                }
+
+                @Override
+                public Traversable emptyTraversable() {
+                    return HashSet.empty();
+                }
+            };
         }
 
     }}

From 2a00f368679bf16d8594b7cb466e9e0d5ecdb9d3 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 11:58:47 +0100
Subject: [PATCH 10/30] Nested Eithers

---
 .../com/aol/cyclops/vavr/hkt/EitherKind.java  |   5 +
 .../java/cyclops/companion/vavr/Eithers.java  | 261 +++++++++++++++---
 .../java/cyclops/companion/vavr/Streams.java  | 146 ++++++++++
 .../java/cyclops/companion/vavr/Trys.java     | 152 +++++++++-
 4 files changed, 524 insertions(+), 40 deletions(-)

diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java
index 2846eda0..1fc6f4b7 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/EitherKind.java
@@ -49,6 +49,11 @@ public interface EitherKind<L,R> extends Either<L,R>,To<EitherKind<L,R>>,
     default <R2> EitherKind<L,R2> fold(Function<? super Either<? super L,? super R>,? extends Either<L,R2>> op){
         return widen(op.apply(this));
     }
+    public static <L,R> Higher<Higher<either,L>,R> widenK(final Either<L,R> completableList) {
+
+        return new EitherKind.Box<>(
+                completableList);
+    }
     public static <L,R> EitherKind<L,R> widen(final Either<L,R> either) {
         return new Box<>(either);
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
index 6dc0a20b..d823bd98 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
@@ -1,6 +1,8 @@
 package cyclops.companion.vavr;
 
+import io.vavr.Lazy;
 import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
 import cyclops.VavrConverters;
@@ -55,9 +57,14 @@
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
+import java.nio.file.WatchEvent;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
-import java.util.stream.Stream;
+
+
+import static com.aol.cyclops.vavr.hkt.EitherKind.widen;
 
 /**
  * Utility class for working with Eithers
@@ -70,7 +77,7 @@ public class Eithers {
 
 
     public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproduct(Either<L,T> either, InstanceDefinitions<W1> def1){
-        return Coproduct.of(Xor.primary(EitherKind.widen(either)),def1,Instances.definitions());
+        return Coproduct.of(Xor.primary(widen(either)),def1,Instances.definitions());
     }
     public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorM(Either<L,T> type){
         return XorM.right(anyM(type));
@@ -279,7 +286,7 @@ public static <L,T> Either<L,ListX<T>> sequencePresent(final CollectionX<Either<
      * @param opts Maybes to Sequence
      * @return  Either with a List of values
      */
-    public static <L,T> Either<L,ReactiveSeq<T>> sequence(final Stream<Either<L,T>> opts) {
+    public static <L,T> Either<L,ReactiveSeq<T>> sequence(final java.util.stream.Stream<Either<L,T>> opts) {
         return AnyM.sequence(opts.map(Eithers::anyM), either.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(VavrWitness::either);
@@ -469,11 +476,11 @@ public static <L,T> Either<L,T> narrow(final Either<L,? extends T> eitheral) {
 
 
     public static <L,R> Active<Higher<either,L>,R> allTypeclasses(Either<L,R> either){
-        return Active.of(EitherKind.widen(either), Eithers.Instances.definitions());
+        return Active.of(widen(either), Eithers.Instances.definitions());
     }
     public static <L,R,W2,R2> Nested<Higher<either,L>,W2,R2> mapM(Either<L,R> either, Function<? super R,? extends Higher<W2,R2>> fn, InstanceDefinitions<W2> defs){
         Either<L, Higher<W2, R2>> e = either.bimap(i -> i, i -> fn.apply(i));
-        EitherKind<L, Higher<W2, R2>> ek = EitherKind.widen(e);
+        EitherKind<L, Higher<W2, R2>> ek = widen(e);
         return Nested.of(ek, Eithers.Instances.definitions(), defs);
     }
     public <L,R,W extends WitnessType<W>> XorT<W, L, R> liftM(Either<L,R> either, W witness) {
@@ -482,7 +489,7 @@ public <L,R,W extends WitnessType<W>> XorT<W, L, R> liftM(Either<L,R> either, W
 
     public static class Instances {
 
-        public static <L> InstanceDefinitions<Higher<either, L>> definitions(){
+        public static <L> InstanceDefinitions<Higher<either, L>> definitions() {
             return new InstanceDefinitions<Higher<either, L>>() {
                 @Override
                 public <T, R> Functor<Higher<either, L>> functor() {
@@ -540,16 +547,18 @@ public <T> Maybe<Unfoldable<Higher<either, L>>> unfoldable() {
                 }
             };
         }
+
         public static <L> Functor<Higher<either, L>> functor() {
             return new Functor<Higher<either, L>>() {
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.bimap(i->i,r->fn.apply(r)));
+                    Either<L, T> either = EitherKind.narrowK(ds);
+                    return widen(either.bimap(i -> i, r -> fn.apply(r)));
                 }
             };
         }
+
         public static <L> Pure<Higher<either, L>> unit() {
             return new Pure<Higher<either, L>>() {
 
@@ -559,20 +568,21 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
                 }
             };
         }
+
         public static <L> Applicative<Higher<either, L>> applicative() {
             return new Applicative<Higher<either, L>>() {
 
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
-                    Either<L,T> either = EitherKind.narrowK(apply);
+                    Either<L, T> either = EitherKind.narrowK(apply);
                     Either<L, ? extends Function<T, R>> eitherFn = EitherKind.narrowK(fn);
-                    return EitherKind.widen(Eithers.xor(ToCyclopsReact.xor(eitherFn).combine(ToCyclopsReact.xor(either),(a,b)->a.apply(b))));
+                    return widen(Eithers.xor(ToCyclopsReact.xor(eitherFn).combine(ToCyclopsReact.xor(either), (a, b) -> a.apply(b))));
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
-                    return Instances.<L>functor().map(fn,ds);
+                    return Instances.<L>functor().map(fn, ds);
                 }
 
                 @Override
@@ -581,24 +591,25 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
                 }
             };
         }
+
         public static <L> Monad<Higher<either, L>> monad() {
             return new Monad<Higher<either, L>>() {
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
+                    Either<L, T> either = EitherKind.narrowK(ds);
+                    return widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
-                    return Instances.<L>applicative().ap(fn,apply);
+                    return Instances.<L>applicative().ap(fn, apply);
 
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
-                    return Instances.<L>functor().map(fn,ds);
+                    return Instances.<L>functor().map(fn, ds);
                 }
 
                 @Override
@@ -607,32 +618,32 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
                 }
             };
         }
+
         public static <L> Traverse<Higher<either, L>> traverse() {
             return new Traverse<Higher<either, L>>() {
 
                 @Override
                 public <C2, T, R> Higher<C2, Higher<Higher<either, L>, R>> traverseA(Applicative<C2> applicative, Function<? super T, ? extends Higher<C2, R>> fn, Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> maybe = EitherKind.narrowK(ds);
-                    return maybe.fold(left->  applicative.unit(EitherKind.<L,R>leftK(left)),
-                            right->applicative.map(m->EitherKind.rightK(m), fn.apply(right)));
+                    Either<L, T> maybe = EitherKind.narrowK(ds);
+                    return maybe.fold(left -> applicative.unit(EitherKind.<L, R>leftK(left)),
+                            right -> applicative.map(m -> EitherKind.rightK(m), fn.apply(right)));
                 }
 
                 @Override
                 public <C2, T> Higher<C2, Higher<Higher<either, L>, T>> sequenceA(Applicative<C2> applicative, Higher<Higher<either, L>, Higher<C2, T>> ds) {
-                    return traverseA(applicative,Function.identity(),ds);
+                    return traverseA(applicative, Function.identity(), ds);
                 }
 
 
-
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
-                    return Instances.<L>applicative().ap(fn,apply);
+                    return Instances.<L>applicative().ap(fn, apply);
 
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
-                    return Instances.<L>functor().map(fn,ds);
+                    return Instances.<L>functor().map(fn, ds);
                 }
 
                 @Override
@@ -641,23 +652,25 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
                 }
             };
         }
+
         public static <L> Foldable<Higher<either, L>> foldable() {
             return new Foldable<Higher<either, L>>() {
 
 
                 @Override
                 public <T> T foldRight(Monoid<T> monoid, Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> either = EitherKind.narrowK(ds);
+                    Either<L, T> either = EitherKind.narrowK(ds);
                     return ToCyclopsReact.xor(either).foldRight(monoid);
                 }
 
                 @Override
                 public <T> T foldLeft(Monoid<T> monoid, Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> either = EitherKind.narrowK(ds);
+                    Either<L, T> either = EitherKind.narrowK(ds);
                     return ToCyclopsReact.xor(either).foldLeft(monoid);
                 }
             };
         }
+
         public static <L> MonadZero<Higher<either, L>> monadZero() {
             return new MonadZero<Higher<either, L>>() {
 
@@ -668,19 +681,19 @@ public static <L> MonadZero<Higher<either, L>> monadZero() {
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
+                    Either<L, T> either = EitherKind.narrowK(ds);
+                    return widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
-                    return Instances.<L>applicative().ap(fn,apply);
+                    return Instances.<L>applicative().ap(fn, apply);
 
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
-                    return Instances.<L>functor().map(fn,ds);
+                    return Instances.<L>functor().map(fn, ds);
                 }
 
                 @Override
@@ -689,17 +702,19 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
                 }
             };
         }
+
         public static <L> MonadPlus<Higher<either, L>> monadPlus() {
-            Monoid m = Monoids.firstPrimaryXor((Either)EitherKind.narrowK(Instances.<L>monadZero().zero()));
+            Monoid m = Monoids.firstPrimaryXor((Either) EitherKind.narrowK(Instances.<L>monadZero().zero()));
 
             return monadPlus(m);
         }
-        public static <L,T> MonadPlus<Higher<either, L>> monadPlus(Monoid<Higher<Higher<either, L>, T>> m) {
+
+        public static <L, T> MonadPlus<Higher<either, L>> monadPlus(Monoid<Higher<Higher<either, L>, T>> m) {
             return new MonadPlus<Higher<either, L>>() {
 
                 @Override
                 public Monoid<Higher<Higher<either, L>, ?>> monoid() {
-                    return (Monoid)m;
+                    return (Monoid) m;
                 }
 
                 @Override
@@ -709,19 +724,19 @@ public static <L,T> MonadPlus<Higher<either, L>> monadPlus(Monoid<Higher<Higher<
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
+                    Either<L, T> either = EitherKind.narrowK(ds);
+                    return widen(either.flatMap(fn.andThen(EitherKind::narrowK)));
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
-                    return Instances.<L>applicative().ap(fn,apply);
+                    return Instances.<L>applicative().ap(fn, apply);
 
                 }
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
-                    return Instances.<L>functor().map(fn,ds);
+                    return Instances.<L>functor().map(fn, ds);
                 }
 
                 @Override
@@ -730,20 +745,21 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
                 }
             };
         }
+
         public static <L> Comonad<Higher<either, L>> comonad() {
             return new ComonadByPure<Higher<either, L>>() {
 
 
                 @Override
                 public <T> T extract(Higher<Higher<either, L>, T> ds) {
-                    Either<L,T> either = EitherKind.narrowK(ds);
+                    Either<L, T> either = EitherKind.narrowK(ds);
                     return either.get();
                 }
 
 
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
-                    return Instances.<L>functor().map(fn,ds);
+                    return Instances.<L>functor().map(fn, ds);
                 }
 
                 @Override
@@ -752,6 +768,175 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
                 }
             };
         }
+
+        public static interface Nesteds {
+
+
+            public static <L, T> Nested<Higher<either, L>, lazy, T> lazy(Either<L, Lazy<T>> type) {
+                return Nested.of(widen(type.map(LazyKind::widen)), Instances.definitions(), Lazys.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, VavrWitness.tryType, T> eitherTry(Either<L, Try<T>> type) {
+                return Nested.of(widen(type.map(TryKind::widen)), Instances.definitions(), Trys.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, VavrWitness.future, T> future(Either<L, Future<T>> type) {
+                return Nested.of(widen(type.map(FutureKind::widen)), Instances.definitions(), Futures.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, Higher<either, L>, T> either(Either<L, Either<L, T>> nested) {
+                return Nested.of(widen(nested.map(EitherKind::widen)), Instances.definitions(), Eithers.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, VavrWitness.queue, T> queue(Either<L, Queue<T>> nested) {
+                return Nested.of(widen(nested.map(QueueKind::widen)), Instances.definitions(), Queues.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, VavrWitness.stream, T> stream(Either<L, Stream<T>> nested) {
+                return Nested.of(widen(nested.map(StreamKind::widen)), Instances.definitions(), Streams.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, VavrWitness.list, T> list(Either<L, List<T>> nested) {
+                return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(), Lists.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, array, T> array(Either<L, Array<T>> nested) {
+                return Nested.of(widen(nested.map(ArrayKind::widen)), Instances.definitions(), Arrays.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, vector, T> vector(Either<L, Vector<T>> nested) {
+                return Nested.of(widen(nested.map(VectorKind::widen)), Instances.definitions(), Vectors.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, VavrWitness.set, T> set(Either<L, HashSet<T>> nested) {
+                return Nested.of(widen(nested.map(SetKind::widen)), Instances.definitions(), Sets.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, reactiveSeq, T> reactiveSeq(Either<L, ReactiveSeq<T>> nested) {
+                EitherKind<L, ReactiveSeq<T>> x = widen(nested);
+                EitherKind<L, Higher<reactiveSeq, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), ReactiveSeq.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, maybe, T> maybe(Either<L, Maybe<T>> nested) {
+                EitherKind<L, Maybe<T>> x = widen(nested);
+                EitherKind<L, Higher<maybe, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), Maybe.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, eval, T> eval(Either<L, Eval<T>> nested) {
+                EitherKind<L, Eval<T>> x = widen(nested);
+                EitherKind<L, Higher<eval, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), Eval.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, Witness.future, T> cyclopsFuture(Either<L, cyclops.async.Future<T>> nested) {
+                EitherKind<L, cyclops.async.Future<T>> x = widen(nested);
+                EitherKind<L, Higher<Witness.future, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), cyclops.async.Future.Instances.definitions());
+            }
+
+            public static <L, S, P> Nested<Higher<either, L>, Higher<xor, S>, P> xor(Either<L, Xor<S, P>> nested) {
+                EitherKind<L, Xor<S, P>> x = widen(nested);
+                EitherKind<L, Higher<Higher<xor, S>, P>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), Xor.Instances.definitions());
+            }
+
+            public static <L, S, T> Nested<Higher<either, L>, Higher<reader, S>, T> reader(Either<L, Reader<S, T>> nested) {
+                EitherKind<L, Reader<S, T>> x = widen(nested);
+                EitherKind<L, Higher<Higher<reader, S>, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), Reader.Instances.definitions());
+            }
+
+            public static <L, S extends Throwable, P> Nested<Higher<either, L>, Higher<Witness.tryType, S>, P> cyclopsTry(Either<L, cyclops.control.Try<P, S>> nested) {
+                EitherKind<L, cyclops.control.Try<P, S>> x = widen(nested);
+                EitherKind<L, Higher<Higher<Witness.tryType, S>, P>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), cyclops.control.Try.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, optional, T> optionalal(Either<L, Optional<T>> nested) {
+                EitherKind<L, Optional<T>> x = widen(nested);
+                EitherKind<L, Higher<optional, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), Optionals.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, completableFuture, T> completableEither(Either<L, CompletableFuture<T>> nested) {
+                EitherKind<L, CompletableFuture<T>> x = widen(nested);
+                EitherKind<L, Higher<completableFuture, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+            }
+
+            public static <L, T> Nested<Higher<either, L>, Witness.stream, T> javaStream(Either<L, java.util.stream.Stream<T>> nested) {
+                EitherKind<L, java.util.stream.Stream<T>> x = widen(nested);
+                EitherKind<L, Higher<Witness.stream, T>> y = (EitherKind) x;
+                return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+            }
+
+            public static interface Reversed {
+                public static <L, T> Nested<reactiveSeq, Higher<either, L>, T> reactiveSeq(ReactiveSeq<Either<L, T>> nested) {
+                    ReactiveSeq<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+                    return Nested.of(x, ReactiveSeq.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, T> Nested<maybe, Higher<either, L>, T> maybe(Maybe<Either<L, T>> nested) {
+                    Maybe<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(x, Maybe.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, T> Nested<eval, Higher<either, L>, T> eval(Eval<Either<L, T>> nested) {
+                    Eval<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(x, Eval.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, T> Nested<Witness.future, Higher<either, L>, T> cyclopsFuture(cyclops.async.Future<Either<L, T>> nested) {
+                    cyclops.async.Future<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(x, cyclops.async.Future.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, S, P> Nested<Higher<xor, S>, Higher<either, L>, P> xor(Xor<S, Either<L, P>> nested) {
+                    Xor<S, Higher<Higher<either, L>, P>> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(x, Xor.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, S, T> Nested<Higher<reader, S>, Higher<either, L>, T> reader(Reader<S, Either<L, T>> nested) {
+
+                    Reader<S, Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(x, Reader.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, S extends Throwable, P> Nested<Higher<Witness.tryType, S>, Higher<either, L>, P> cyclopsTry(cyclops.control.Try<Either<L, P>, S> nested) {
+                    cyclops.control.Try<Higher<Higher<either, L>, P>, S> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(x, cyclops.control.Try.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, T> Nested<optional, Higher<either, L>, T> optional(Optional<Either<L, T>> nested) {
+                    Optional<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, T> Nested<completableFuture, Higher<either, L>, T> completableFuture(CompletableFuture<Either<L, T>> nested) {
+                    CompletableFuture<Higher<Higher<either, L>, T>> x = nested.thenApply(EitherKind::widenK);
+
+                    return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(), Instances.definitions());
+                }
+
+                public static <L, T> Nested<Witness.stream, Higher<either, L>, T> javaStream(java.util.stream.Stream<Either<L, T>> nested) {
+                    java.util.stream.Stream<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+
+                    return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(), Instances.definitions());
+                }
+            }
+
+
+        }
     }
 
-}
+
+    }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index bad65203..9b2bdda2 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -1,6 +1,10 @@
 package cyclops.companion.vavr;
 
+import cyclops.monads.VavrWitness.queue;
+import cyclops.monads.VavrWitness.tryType;
+import io.vavr.Lazy;
 import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
 import cyclops.VavrConverters;
@@ -52,6 +56,7 @@
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
@@ -672,6 +677,147 @@ public <R, T> Higher<stream, R> unfold(T b, Function<? super T, Optional<Tuple2<
         }
     }
 
+    public static interface Nesteds{
 
 
+        public static <T> Nested<stream,lazy,T> lazy(Stream<Lazy<T>> type){
+            return Nested.of(widen(type.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <T> Nested<stream,tryType,T> streamTry(Stream<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<stream,VavrWitness.future,T> future(Stream<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<stream,queue,T> queue(Stream<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)),Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <L, R> Nested<stream,Higher<VavrWitness.either,L>, R> either(Stream<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<stream,VavrWitness.stream,T> stream(Stream<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<stream,VavrWitness.list,T> list(Stream<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<stream,array,T> array(Stream<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<stream,vector,T> vector(Stream<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<stream,VavrWitness.set,T> set(Stream<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<stream,reactiveSeq,T> reactiveSeq(Stream<ReactiveSeq<T>> nested){
+            StreamKind<ReactiveSeq<T>> x = widen(nested);
+            StreamKind<Higher<reactiveSeq,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<stream,maybe,T> maybe(Stream<Maybe<T>> nested){
+            StreamKind<Maybe<T>> x = widen(nested);
+            StreamKind<Higher<maybe,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<stream,eval,T> eval(Stream<Eval<T>> nested){
+            StreamKind<Eval<T>> x = widen(nested);
+            StreamKind<Higher<eval,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<stream,Witness.future,T> cyclopsFuture(Stream<cyclops.async.Future<T>> nested){
+            StreamKind<cyclops.async.Future<T>> x = widen(nested);
+            StreamKind<Higher<Witness.future,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<stream,Higher<xor,S>, P> xor(Stream<Xor<S, P>> nested){
+            StreamKind<Xor<S, P>> x = widen(nested);
+            StreamKind<Higher<Higher<xor,S>, P>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<stream,Higher<reader,S>, T> reader(Stream<Reader<S, T>> nested){
+            StreamKind<Reader<S, T>> x = widen(nested);
+            StreamKind<Higher<Higher<reader,S>, T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<stream,Higher<Witness.tryType,S>, P> cyclopsTry(Stream<cyclops.control.Try<P, S>> nested){
+            StreamKind<cyclops.control.Try<P, S>> x = widen(nested);
+            StreamKind<Higher<Higher<Witness.tryType,S>, P>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<stream,optional,T> streamal(Stream<Optional<T>> nested){
+            StreamKind<Optional<T>> x = widen(nested);
+            StreamKind<Higher<optional,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<stream,completableFuture,T> completableStream(Stream<CompletableFuture<T>> nested){
+            StreamKind<CompletableFuture<T>> x = widen(nested);
+            StreamKind<Higher<completableFuture,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<stream,Witness.stream,T> javaStream(Stream<java.util.stream.Stream<T>> nested){
+            StreamKind<java.util.stream.Stream<T>> x = widen(nested);
+            StreamKind<Higher<Witness.stream,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,stream,T> reactiveSeq(ReactiveSeq<Stream<T>> nested){
+                ReactiveSeq<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,stream,T> maybe(Maybe<Stream<T>> nested){
+                Maybe<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,stream,T> eval(Eval<Stream<T>> nested){
+                Eval<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,stream,T> cyclopsFuture(cyclops.async.Future<Stream<T>> nested){
+                cyclops.async.Future<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,stream, P> xor(Xor<S, Stream<P>> nested){
+                Xor<S, Higher<stream,P>> x = nested.map(StreamKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,stream, T> reader(Reader<S, Stream<T>> nested){
+
+                Reader<S, Higher<stream, T>>  x = nested.map(StreamKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,stream, P> cyclopsTry(cyclops.control.Try<Stream<P>, S> nested){
+                cyclops.control.Try<Higher<stream,P>, S> x = nested.map(StreamKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,stream,T> streamal(Optional<Stream<T>> nested){
+                Optional<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,stream,T> completableStream(CompletableFuture<Stream<T>> nested){
+                CompletableFuture<Higher<stream,T>> x = nested.thenApply(StreamKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,stream,T> javaStream(java.util.stream.Stream<Stream<T>> nested){
+                java.util.stream.Stream<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
+
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
index 85961dcc..f881e43a 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
@@ -1,7 +1,10 @@
 package cyclops.companion.vavr;
 
 
+import cyclops.monads.VavrWitness.queue;
+import io.vavr.Lazy;
 import io.vavr.collection.*;
+import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
 import cyclops.VavrConverters;
@@ -57,9 +60,11 @@
 import org.reactivestreams.Publisher;
 
 import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
-import java.util.stream.Stream;
+
 
 import static com.aol.cyclops.vavr.hkt.TryKind.widen;
 
@@ -409,7 +414,7 @@ public static <T> Try<ListX<T>> sequencePresent(final CollectionX<Try<T>> opts)
      * @param opts Maybes to Sequence
      * @return  Try with a List of values
      */
-    public static <T> Try<ReactiveSeq<T>> sequence(final Stream<Try<T>> opts) {
+    public static <T> Try<ReactiveSeq<T>> sequence(final java.util.stream.Stream<Try<T>> opts) {
         return AnyM.sequence(opts.map(Trys::anyM), tryType.INSTANCE)
                 .map(ReactiveSeq::fromStream)
                 .to(VavrWitness::tryType);
@@ -913,5 +918,148 @@ private static <C2,T,R> Higher<C2, Higher<tryType, R>> traverseA(Applicative<C2>
 
     }
 
+    public static interface Nesteds{
+
+
+        public static <T> Nested<tryType,lazy,T> lazy(Try<Lazy<T>> type){
+            return Nested.of(widen(type.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
+        }
+        public static <T> Nested<tryType,tryType,T> tryTry(Try<Try<T>> type){
+            return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
+        }
+        public static <T> Nested<tryType,VavrWitness.future,T> future(Try<Future<T>> type){
+            return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
+        }
+        public static <T> Nested<tryType,queue,T> queue(Try<Queue<T>> nested){
+            return Nested.of(widen(nested.map(QueueKind::widen)),Instances.definitions(),Queues.Instances.definitions());
+        }
+        public static <L, R> Nested<tryType,Higher<VavrWitness.either,L>, R> either(Try<Either<L, R>> nested){
+            return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
+        }
+        public static <T> Nested<tryType,VavrWitness.stream,T> stream(Try<Stream<T>> nested){
+            return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
+        }
+        public static <T> Nested<tryType,VavrWitness.list,T> list(Try<List<T>> nested){
+            return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<tryType,array,T> array(Try<Array<T>> nested){
+            return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
+        }
+        public static <T> Nested<tryType,vector,T> vector(Try<Vector<T>> nested){
+            return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
+        }
+        public static <T> Nested<tryType,VavrWitness.set,T> set(Try<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        }
+
+        public static <T> Nested<tryType,reactiveSeq,T> reactiveSeq(Try<ReactiveSeq<T>> nested){
+            TryKind<ReactiveSeq<T>> x = widen(nested);
+            TryKind<Higher<reactiveSeq,T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<tryType,maybe,T> maybe(Try<Maybe<T>> nested){
+            TryKind<Maybe<T>> x = widen(nested);
+            TryKind<Higher<maybe,T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<tryType,eval,T> eval(Try<Eval<T>> nested){
+            TryKind<Eval<T>> x = widen(nested);
+            TryKind<Higher<eval,T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<tryType,Witness.future,T> cyclopsFuture(Try<cyclops.async.Future<T>> nested){
+            TryKind<cyclops.async.Future<T>> x = widen(nested);
+            TryKind<Higher<Witness.future,T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<tryType,Higher<xor,S>, P> xor(Try<Xor<S, P>> nested){
+            TryKind<Xor<S, P>> x = widen(nested);
+            TryKind<Higher<Higher<xor,S>, P>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<tryType,Higher<reader,S>, T> reader(Try<Reader<S, T>> nested){
+            TryKind<Reader<S, T>> x = widen(nested);
+            TryKind<Higher<Higher<reader,S>, T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<tryType,Higher<Witness.tryType,S>, P> cyclopsTry(Try<cyclops.control.Try<P, S>> nested){
+            TryKind<cyclops.control.Try<P, S>> x = widen(nested);
+            TryKind<Higher<Higher<Witness.tryType,S>, P>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<tryType,optional,T> tryTypeal(Try<Optional<T>> nested){
+            TryKind<Optional<T>> x = widen(nested);
+            TryKind<Higher<optional,T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+        public static <T> Nested<tryType,completableFuture,T> completableTry(Try<CompletableFuture<T>> nested){
+            TryKind<CompletableFuture<T>> x = widen(nested);
+            TryKind<Higher<completableFuture,T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<tryType,Witness.stream,T> javaStream(Try<java.util.stream.Stream<T>> nested){
+            TryKind<java.util.stream.Stream<T>> x = widen(nested);
+            TryKind<Higher<Witness.stream,T>> y = (TryKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,tryType,T> reactiveSeq(ReactiveSeq<Try<T>> nested){
+                ReactiveSeq<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,tryType,T> maybe(Maybe<Try<T>> nested){
+                Maybe<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,tryType,T> eval(Eval<Try<T>> nested){
+                Eval<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,tryType,T> cyclopsFuture(cyclops.async.Future<Try<T>> nested){
+                cyclops.async.Future<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,tryType, P> xor(Xor<S, Try<P>> nested){
+                Xor<S, Higher<tryType,P>> x = nested.map(TryKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,tryType, T> reader(Reader<S, Try<T>> nested){
+
+                Reader<S, Higher<tryType, T>>  x = nested.map(TryKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,tryType, P> cyclopsTry(cyclops.control.Try<Try<P>, S> nested){
+                cyclops.control.Try<Higher<tryType,P>, S> x = nested.map(TryKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,tryType,T> tryTypeal(Optional<Try<T>> nested){
+                Optional<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,tryType,T> completableTry(CompletableFuture<Try<T>> nested){
+                CompletableFuture<Higher<tryType,T>> x = nested.thenApply(TryKind::widenK);
+
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,tryType,T> javaStream(java.util.stream.Stream<Try<T>> nested){
+                java.util.stream.Stream<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
+
 
 }

From 7880366880bbe4dab6d811161ccdff8f7634e84d Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 12:50:45 +0100
Subject: [PATCH 11/30] Guava migration

---
 .../functionaljava/adapter/EitherAdapter.java |   8 +-
 .../adapter/IterableWAdapter.java             |   8 +-
 .../functionaljava/adapter/ListAdapter.java   |   6 +-
 .../adapter/NonEmptyListAdapter.java          |   7 +-
 .../functionaljava/adapter/OptionAdapter.java |   7 +-
 .../functionaljava/adapter/StreamAdapter.java |   8 +-
 .../adapter/ValidationAdapter.java            |   7 +-
 .../guava/adapter/FluentIterableAdapter.java  |   7 +-
 .../guava/adapter/OptionalAdapter.java        |   6 +-
 .../cyclops/guava/hkt/FluentIterableKind.java |  26 ++
 .../aol/cyclops/guava/hkt/OptionalKind.java   |  35 ++-
 .../companion/guava/FluentIterables.java      | 265 ++++++++++++++++--
 .../cyclops/companion/guava/Optionals.java    | 236 +++++++++++++++-
 .../cyclops/reactor/adapter/FluxAdapter.java  |   5 +
 .../cyclops/reactor/adapter/MonoAdapter.java  |   4 +
 .../cyclops/rx/adapter/ObservableAdapter.java |   7 +-
 .../cyclops/rx2/adapter/FlowableAdapter.java  |   5 +
 .../aol/cyclops/rx2/adapter/MaybeAdapter.java |   5 +
 .../rx2/adapter/ObservableAdapter.java        |   7 +-
 .../cyclops/rx2/adapter/SingleAdapter.java    |   4 +
 .../cyclops/vavr/adapter/EitherAdapter.java   |   7 +-
 .../cyclops/vavr/adapter/FutureAdapter.java   |   7 +-
 .../cyclops/vavr/adapter/OptionAdapter.java   |   6 +-
 .../vavr/adapter/TraversableAdapter.java      |   6 +-
 .../aol/cyclops/vavr/adapter/TryAdapter.java  |   7 +-
 .../java/cyclops/companion/vavr/Lists.java    |   1 +
 .../java/cyclops/companion/vavr/Streams.java  |   2 +-
 .../typeclesses/instances/OptionsTest.java    |   2 +-
 .../hkt/typeclesses/instances/QueuesTest.java |   2 +-
 .../typeclesses/instances/VectorsTest.java    |   2 +-
 gradle.properties                             |   2 +-
 31 files changed, 638 insertions(+), 69 deletions(-)

diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/EitherAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/EitherAdapter.java
index b33b1030..6063a6e4 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/EitherAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/EitherAdapter.java
@@ -2,7 +2,9 @@
 
 
 
+import cyclops.companion.functionaljava.Eithers;
 import cyclops.monads.FJ;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.either;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import cyclops.conversion.functionaljava.ToCyclopsReact;
@@ -70,6 +72,8 @@ public <T> AnyM<either, T> unit(T o) {
         return FJ.either(Either.right(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<either, R> map(AnyM<either, T> t, Function<? super T, ? extends R> fn) {
+        return Eithers.anyM(either(t).bimap(i->i, x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/IterableWAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/IterableWAdapter.java
index b8842304..e917e89d 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/IterableWAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/IterableWAdapter.java
@@ -1,5 +1,7 @@
 package com.aol.cyclops.functionaljava.adapter;
 
+import cyclops.monads.FJ;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.iterableW;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
@@ -66,6 +68,8 @@ public <T> AnyM<iterableW, T> unit(T o) {
         return anyM(IterableW.iterable(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<iterableW, R> map(AnyM<iterableW, T> t, Function<? super T, ? extends R> fn) {
+        return FJ.iterableW(iterableW(t).map(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ListAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ListAdapter.java
index 02b98df8..a973355b 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ListAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ListAdapter.java
@@ -1,5 +1,6 @@
 package com.aol.cyclops.functionaljava.adapter;
 
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.list;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
@@ -66,5 +67,8 @@ public <T> AnyM<list, T> unit(T o) {
     }
 
 
-
+    @Override
+    public <T, R> AnyM<list, R> map(AnyM<list, T> t, Function<? super T, ? extends R> fn) {
+        return anyM(stream(t).map(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/NonEmptyListAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/NonEmptyListAdapter.java
index 02f42570..7234471a 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/NonEmptyListAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/NonEmptyListAdapter.java
@@ -1,5 +1,6 @@
 package com.aol.cyclops.functionaljava.adapter;
 
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.nonEmptyList;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
@@ -65,6 +66,8 @@ public <T> AnyM<nonEmptyList, T> unit(T o) {
         return anyM(NonEmptyList.nel(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<nonEmptyList, R> map(AnyM<nonEmptyList, T> t, Function<? super T, ? extends R> fn) {
+        return anyM(stream(t).map(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/OptionAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/OptionAdapter.java
index 15008a48..692f7e8f 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/OptionAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/OptionAdapter.java
@@ -2,6 +2,7 @@
 
 
 import cyclops.monads.FJ;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.option;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
@@ -66,6 +67,8 @@ public <T> AnyM<option, T> unit(T o) {
         return FJ.option(Option.some(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<option, R> map(AnyM<option, T> t, Function<? super T, ? extends R> fn) {
+        return FJ.option(option(t).map(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/StreamAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/StreamAdapter.java
index faae8576..0187ef83 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/StreamAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/StreamAdapter.java
@@ -1,5 +1,7 @@
 package com.aol.cyclops.functionaljava.adapter;
 
+import cyclops.companion.functionaljava.Streams;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.stream;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
@@ -65,6 +67,8 @@ public <T> AnyM<stream, T> unit(T o) {
         return anyM(Stream.stream(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<stream, R> map(AnyM<stream, T> t, Function<? super T, ? extends R> fn) {
+        return Streams.anyM(stream(t).map(x-> fn.apply(x)));
+    }
 }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java
index 1201201f..57d6611f 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java
@@ -2,6 +2,7 @@
 
 
 import cyclops.monads.FJ;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.validation;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import cyclops.conversion.functionaljava.ToCyclopsReact;
@@ -69,6 +70,8 @@ public <T> AnyM<validation, T> unit(T o) {
         return FJ.validation(Validation.success(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<validation, R> map(AnyM<validation, T> t, Function<? super T, ? extends R> fn) {
+        return FJ.validation(validation(t)).map(x->fn.apply(x));
+    }
 }
diff --git a/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/FluentIterableAdapter.java b/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/FluentIterableAdapter.java
index 5cb80f22..3f2d51c9 100644
--- a/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/FluentIterableAdapter.java
+++ b/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/FluentIterableAdapter.java
@@ -2,6 +2,7 @@
 
 import cyclops.companion.guava.FluentIterables;
 
+import cyclops.monads.GuavaWitness;
 import cyclops.monads.GuavaWitness.fluentIterable;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import com.google.common.collect.FluentIterable;
@@ -68,6 +69,8 @@ public <T> AnyM<fluentIterable, T> unit(T o) {
         return FluentIterables.anyM(FluentIterable.of(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<fluentIterable, R> map(AnyM<fluentIterable, T> t, Function<? super T, ? extends R> fn) {
+        return FluentIterables.anyM(stream(t).transform(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/OptionalAdapter.java b/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/OptionalAdapter.java
index 40369cb6..c399684d 100644
--- a/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/OptionalAdapter.java
+++ b/cyclops-guava/src/main/java/com/aol/cyclops/guava/adapter/OptionalAdapter.java
@@ -71,6 +71,8 @@ public <T> AnyM<optional, T> unit(T o) {
         return Optionals.anyM(Optional.of(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<optional, R> map(AnyM<optional, T> t, Function<? super T, ? extends R> fn) {
+        return Optionals.anyM(future(t).transform(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java
index 5c8ef459..66637cc3 100644
--- a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java
+++ b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/FluentIterableKind.java
@@ -5,9 +5,17 @@
 import java.util.Iterator;
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.guava.FluentIterables;
 import cyclops.monads.GuavaWitness;
 import cyclops.monads.GuavaWitness.fluentIterable;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
+import fj.data.List;
+import io.vavr.collection.Stream;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
@@ -44,7 +52,25 @@
 public final class FluentIterableKind<E> implements Higher<fluentIterable, E>, Publisher<E>, Iterable<E> {
 
 
+    public <R> FluentIterableKind<R> fold(java.util.function.Function<? super FluentIterable<?  super E>,? extends FluentIterable<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<fluentIterable,E> allTypeclasses(){
+        return Active.of(this, FluentIterables.Instances.definitions());
+    }
+
+    public static <T> Higher<fluentIterable,T> widenK(final FluentIterable<T> completableList) {
+
+        return new FluentIterableKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<fluentIterable,W2,R> mapM(java.util.function.Function<? super E,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return FluentIterables.mapM(boxed,fn,defs);
+    }
 
+    public <W extends WitnessType<W>> StreamT<W, E> liftM(W witness) {
+        return FluentIterables.liftM(boxed,witness);
+    }
     /**
      * Construct a HKT encoded completed FluentIterable
      * 
diff --git a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java
index 06756e44..c0ae7a77 100644
--- a/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java
+++ b/cyclops-guava/src/main/java/com/aol/cyclops/guava/hkt/OptionalKind.java
@@ -3,6 +3,9 @@
 
 import java.util.Set;
 
+import com.google.common.collect.FluentIterable;
+import cyclops.companion.guava.FluentIterables;
+import cyclops.companion.guava.Optionals;
 import cyclops.conversion.guava.FromCyclopsReact;
 import cyclops.conversion.guava.FromJDK;
 import cyclops.conversion.guava.ToCyclopsReact;
@@ -17,6 +20,12 @@
 import cyclops.monads.GuavaWitness;
 import cyclops.monads.GuavaWitness.optional;
 import cyclops.monads.Witness;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.OptionalT;
+import cyclops.monads.transformers.StreamT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 
@@ -31,15 +40,25 @@
  */
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class OptionalKind<T> implements Higher<optional, T> {
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
+    public <R> OptionalKind<R> fold(java.util.function.Function<? super Optional<?  super T>,? extends Optional<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<optional,T> allTypeclasses(){
+        return Active.of(this, Optionals.Instances.definitions());
+    }
+
+    public static <T> Higher<optional,T> widenK(final Optional<T> completableList) {
+
+        return new OptionalKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<optional,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Optionals.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> OptionalT<W, T> liftM(W witness) {
+        return Optionals.liftM(boxed,witness);
     }
-    
     /**
      * @return Get the empty Optional (single instance)
      */
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
index 50465226..77228f85 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
@@ -1,5 +1,15 @@
 package cyclops.companion.guava;
 
+import com.aol.cyclops.guava.hkt.OptionalKind;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Streams;
+import cyclops.companion.Streams.StreamKind;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.monads.*;
 import cyclops.monads.GuavaWitness.fluentIterable;
 import com.aol.cyclops.guava.hkt.FluentIterableKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -8,22 +18,41 @@
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
-import cyclops.monads.AnyM;
+import cyclops.monads.Witness.*;
+import cyclops.monads.transformers.ListT;
+import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.vavr.collection.List;
+import io.vavr.collection.Stream;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.*;
 
+import static com.aol.cyclops.guava.hkt.FluentIterableKind.widen;
+
 /**
  * Created by johnmcclean on 26/04/2017.
  */
 public class FluentIterables {
-
+    public static  <W1,T> Coproduct<W1,fluentIterable,T> coproduct(FluentIterable<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,fluentIterable,T> xorM(FluentIterable<T> type){
+        return XorM.right(anyM(type));
+    }
+    public static <T,W extends WitnessType<W>> StreamT<W, T> liftM(FluentIterable<T> opt, W witness) {
+        return StreamT.of(witness.adapter().unit(ReactiveSeq.fromIterable(opt)));
+    }
     /**
      * <pre>
      * {@code
@@ -312,15 +341,80 @@ public static <T, R1, R> FluentIterable<R> forEach2(FluentIterable<? extends T>
                     .transform(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+    public static <T> Active<fluentIterable,T> allTypeclasses(FluentIterable<T> array){
+        return Active.of(widen(array), FluentIterables.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<fluentIterable,W2,R> mapM(FluentIterable<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        FluentIterable<Higher<W2, R>> e = array.transform(x->fn.apply(x));
+        FluentIterableKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, FluentIterables.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with FluentIterables
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public class Instances {
 
-
+        public static InstanceDefinitions<fluentIterable> definitions() {
+            return new InstanceDefinitions<fluentIterable>() {
+
+                @Override
+                public <T, R> Functor<fluentIterable> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<fluentIterable> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<fluentIterable> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<fluentIterable> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<fluentIterable>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<fluentIterable>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<fluentIterable>> monadPlus(Monoid<Higher<fluentIterable, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<fluentIterable>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<fluentIterable>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<fluentIterable>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<fluentIterable>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
         /**
          *
          * Transform a flux, mulitplying every element by 2
@@ -461,7 +555,7 @@ public static <T,R> Monad<fluentIterable> monad(){
          */
         public static <T,R> MonadZero<fluentIterable> monadZero(){
             BiFunction<Higher<fluentIterable,T>,Predicate<? super T>,Higher<fluentIterable,T>> filter = Instances::filter;
-            Supplier<Higher<fluentIterable, T>> zero = ()-> FluentIterableKind.widen(FluentIterable.of());
+            Supplier<Higher<fluentIterable, T>> zero = ()-> widen(FluentIterable.of());
             return General.<fluentIterable,T,R>monadZero(monad(), zero,filter);
         }
         /**
@@ -477,7 +571,7 @@ public static <T,R> MonadZero<fluentIterable> monadZero(){
          * @return Type class for combining FluentIterables by concatenation
          */
         public static <T> MonadPlus<fluentIterable> monadPlus(){
-            Monoid<FluentIterableKind<T>> m = Monoid.of(FluentIterableKind.widen(FluentIterable.<T>of()), Instances::concat);
+            Monoid<FluentIterableKind<T>> m = Monoid.of(widen(FluentIterable.<T>of()), Instances::concat);
             Monoid<Higher<fluentIterable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -497,7 +591,11 @@ public static <T> MonadPlus<fluentIterable> monadPlus(){
          * @param m Monoid to use for combining FluentIterables
          * @return Type class for combining FluentIterables
          */
-        public static <T> MonadPlus<fluentIterable> monadPlus(Monoid<FluentIterableKind<T>> m){
+        public static <T> MonadPlus<fluentIterable> monadPlusK(Monoid<FluentIterableKind<T>> m){
+            Monoid<Higher<fluentIterable,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<fluentIterable> monadPlus(Monoid<Higher<fluentIterable,T>> m){
             Monoid<Higher<fluentIterable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -508,11 +606,11 @@ public static <T> MonadPlus<fluentIterable> monadPlus(Monoid<FluentIterableKind<
         public static <C2,T> Traverse<fluentIterable> traverse(){
             BiFunction<Applicative<C2>,FluentIterableKind<Higher<C2, T>>,Higher<C2, FluentIterableKind<T>>> sequenceFn = (ap, flux) -> {
 
-                Higher<C2,FluentIterableKind<T>> identity = ap.unit(FluentIterableKind.widen(FluentIterable.of()));
+                Higher<C2,FluentIterableKind<T>> identity = ap.unit(widen(FluentIterable.of()));
 
-                BiFunction<Higher<C2,FluentIterableKind<T>>,Higher<C2,T>,Higher<C2,FluentIterableKind<T>>> combineToFluentIterable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> FluentIterableKind.widen(FluentIterable.concat(a,FluentIterable.of(b)))),acc,next);
+                BiFunction<Higher<C2,FluentIterableKind<T>>,Higher<C2,T>,Higher<C2,FluentIterableKind<T>>> combineToFluentIterable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(FluentIterable.concat(a,FluentIterable.of(b)))),acc,next);
 
-                BinaryOperator<Higher<C2,FluentIterableKind<T>>> combineFluentIterables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return FluentIterableKind.widen(FluentIterable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
+                BinaryOperator<Higher<C2,FluentIterableKind<T>>> combineFluentIterables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return widen(FluentIterable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
 
                 return ReactiveSeq.fromIterable(flux).reduce(identity,
                         combineToFluentIterable,
@@ -547,23 +645,156 @@ public static <T> Foldable<fluentIterable> foldable(){
         }
 
         private static  <T> FluentIterableKind<T> concat(FluentIterableKind<T> l1, FluentIterableKind<T> l2){
-            return FluentIterableKind.widen(FluentIterable.concat(l1,l2));
+            return widen(FluentIterable.concat(l1,l2));
         }
         private <T> FluentIterableKind<T> of(T value){
-            return FluentIterableKind.widen(FluentIterable.of(value));
+            return widen(FluentIterable.of(value));
         }
         private static <T,R> FluentIterableKind<R> ap(FluentIterableKind<Function< T, R>> lt, FluentIterableKind<T> flux){
-            return FluentIterableKind.widen(lt.toReactiveSeq().zip(flux,(a, b)->a.apply(b)));
+            return widen(lt.toReactiveSeq().zip(flux,(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<fluentIterable,R> transformAndConcat(Higher<fluentIterable,T> lt, Function<? super T, ? extends  Higher<fluentIterable,R>> fn){
-            return FluentIterableKind.widen(FluentIterableKind.narrowK(lt).transformAndConcat(i->fn.andThen(FluentIterableKind::narrowK).apply(i)));
+            return widen(FluentIterableKind.narrowK(lt).transformAndConcat(i->fn.andThen(FluentIterableKind::narrowK).apply(i)));
         }
         private static <T,R> FluentIterableKind<R> transform(FluentIterableKind<T> lt, Function<? super T, ? extends R> fn){
-            return FluentIterableKind.widen(lt.transform(i->fn.apply(i)));
+            return widen(lt.transform(i->fn.apply(i)));
         }
         private static <T> FluentIterableKind<T> filter(Higher<fluentIterable,T> lt, Predicate<? super T> fn){
-            return FluentIterableKind.widen(FluentIterableKind.narrow(lt).filter(i->fn.test(i)));
+            return widen(FluentIterableKind.narrow(lt).filter(i->fn.test(i)));
+        }
+        public static Unfoldable<fluentIterable> unfoldable(){
+            return new Unfoldable<fluentIterable>() {
+                @Override
+                public <R, T> Higher<fluentIterable, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return widen(FluentIterable.from(ReactiveSeq.unfold(b,fn)));
+
+                }
+            };
         }
     }
 
+    public static interface Nesteds{
+        public static <T> Nested<fluentIterable,GuavaWitness.optional,T> optional(FluentIterable<com.google.common.base.Optional<T>> nested){
+            FluentIterableKind<com.google.common.base.Optional<T>> x = widen(nested);
+            FluentIterableKind<Higher<GuavaWitness.optional,T>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
+        }
+
+
+
+        public static <T> Nested<fluentIterable,reactiveSeq,T> reactiveSeq(FluentIterable<ReactiveSeq<T>> nested){
+            FluentIterableKind<ReactiveSeq<T>> x = widen(nested);
+            FluentIterableKind<Higher<reactiveSeq,T>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<fluentIterable,maybe,T> maybe(FluentIterable<Maybe<T>> nested){
+            FluentIterableKind<Maybe<T>> x = widen(nested);
+            FluentIterableKind<Higher<maybe,T>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<fluentIterable,eval,T> eval(FluentIterable<Eval<T>> nested){
+            FluentIterableKind<Eval<T>> x = widen(nested);
+            FluentIterableKind<Higher<eval,T>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<fluentIterable,Witness.future,T> future(FluentIterable<cyclops.async.Future<T>> nested){
+            FluentIterableKind<cyclops.async.Future<T>> x = widen(nested);
+            FluentIterableKind<Higher<Witness.future,T>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<fluentIterable,Higher<xor,S>, P> xor(FluentIterable<Xor<S, P>> nested){
+            FluentIterableKind<Xor<S, P>> x = widen(nested);
+            FluentIterableKind<Higher<Higher<xor,S>, P>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<fluentIterable,Higher<reader,S>, T> reader(FluentIterable<Reader<S, T>> nested){
+            FluentIterableKind<Reader<S, T>> x = widen(nested);
+            FluentIterableKind<Higher<Higher<reader,S>, T>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<fluentIterable,Higher<Witness.tryType,S>, P> cyclopsTry(FluentIterable<cyclops.control.Try<P, S>> nested){
+            FluentIterableKind<cyclops.control.Try<P, S>> x = widen(nested);
+            FluentIterableKind<Higher<Higher<Witness.tryType,S>, P>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<fluentIterable,Witness.optional,T> javaOptional(FluentIterable<Optional<T>> nested){
+            FluentIterable<cyclops.companion.Optionals.OptionalKind<T>> f = nested.transform(o -> cyclops.companion.Optionals.OptionalKind.widen(o));
+            FluentIterableKind<cyclops.companion.Optionals.OptionalKind<T>> x = FluentIterableKind.widen(f);
+
+            FluentIterableKind<Higher<Witness.optional,T>> y = (FluentIterableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<fluentIterable,completableFuture,T> completableOptional(FluentIterable<CompletableFuture<T>> nested){
+            FluentIterable<CompletableFutureKind<T>> f = nested.transform(o -> CompletableFutureKind.widen(o));
+            FluentIterableKind<CompletableFutureKind<T>> x = FluentIterableKind.widen(f);
+            FluentIterableKind<Higher<completableFuture,T>> y = (FluentIterableKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<fluentIterable,Witness.stream,T> javaStream(FluentIterable<java.util.stream.Stream<T>> nested){
+            FluentIterable<StreamKind<T>> f = nested.transform(o -> StreamKind.widen(o));
+            FluentIterableKind<StreamKind<T>> x = FluentIterableKind.widen(f);
+            FluentIterableKind<Higher<Witness.stream,T>> y = (FluentIterableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,fluentIterable,T> reactiveSeq(ReactiveSeq<FluentIterable<T>> nested){
+                ReactiveSeq<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,fluentIterable,T> maybe(Maybe<FluentIterable<T>> nested){
+                Maybe<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,fluentIterable,T> eval(Eval<FluentIterable<T>> nested){
+                Eval<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,fluentIterable,T> future(cyclops.async.Future<FluentIterable<T>> nested){
+                cyclops.async.Future<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,fluentIterable, P> xor(Xor<S, FluentIterable<P>> nested){
+                Xor<S, Higher<fluentIterable,P>> x = nested.map(FluentIterableKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,fluentIterable, T> reader(Reader<S, FluentIterable<T>> nested){
+
+                Reader<S, Higher<fluentIterable, T>>  x = nested.map(FluentIterableKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,fluentIterable, P> cyclopsTry(cyclops.control.Try<FluentIterable<P>, S> nested){
+                cyclops.control.Try<Higher<fluentIterable,P>, S> x = nested.map(FluentIterableKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<optional,fluentIterable,T> javaOptional(Optional<FluentIterable<T>> nested){
+                Optional<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+
+                return  Nested.of(cyclops.companion.Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,fluentIterable,T> completableFluentIterable(CompletableFuture<FluentIterable<T>> nested){
+                CompletableFuture<Higher<fluentIterable,T>> x = nested.thenApply(FluentIterableKind::widenK);
+
+                return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,fluentIterable,T> javaStream(java.util.stream.Stream<FluentIterable<T>> nested){
+                java.util.stream.Stream<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+
+                return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
+
+
 }
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
index d06094e1..167ee757 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
@@ -1,10 +1,21 @@
 package cyclops.companion.guava;
 
+import com.aol.cyclops.guava.hkt.FluentIterableKind;
+import com.google.common.collect.FluentIterable;
+import cyclops.async.Future;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Streams;
+import cyclops.companion.Streams.StreamKind;
+import cyclops.control.Eval;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.conversion.guava.FromCyclopsReact;
 import cyclops.conversion.guava.FromJDK;
 import cyclops.conversion.guava.ToCyclopsReact;
 import cyclops.conversion.guava.ToJDK;
-import cyclops.monads.GuavaWitness;
+import cyclops.monads.*;
+import cyclops.monads.GuavaWitness.fluentIterable;
 import cyclops.monads.GuavaWitness.optional;
 import com.aol.cyclops.guava.hkt.OptionalKind;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
@@ -18,13 +29,14 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
-import cyclops.monads.AnyM;
-import cyclops.monads.WitnessType;
+import cyclops.monads.Witness.*;
 import cyclops.monads.transformers.OptionalT;
+import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
@@ -34,10 +46,15 @@
 import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.OptionalLong;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+import static com.aol.cyclops.guava.hkt.FluentIterableKind.widen;
+import static com.aol.cyclops.guava.hkt.OptionalKind.widen;
+import static cyclops.companion.Streams.StreamKind.*;
+
 /**
  * Created by johnmcclean on 26/04/2017.
  */
@@ -592,6 +609,21 @@ public static <T> Optional<T> narrow(final Optional<? extends T> optional) {
         return (Optional<T>) optional;
     }
 
+    public static <T> Active<optional,T> allTypeclasses(Optional<T> type){
+        return Active.of(widen(type), Optionals.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<optional,W2,R> mapM(Optional<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Optional<Higher<W2, R>> e = type.transform(x->fn.apply(x));
+        Higher<optional, Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, Optionals.Instances.definitions(), defs);
+    }
+    public static  <W1,T> Coproduct<W1,optional,T> coproduct(Optional<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,optional,T> xorM(Optional<T> type){
+        return XorM.right(anyM(type));
+    }
+
     /**
      * Companion class for creating Type Class instances for working with Optionals
      * @author johnmcclean
@@ -599,6 +631,65 @@ public static <T> Optional<T> narrow(final Optional<? extends T> optional) {
      */
     @UtilityClass
     public class Instances {
+        public static InstanceDefinitions<optional> definitions() {
+            return new InstanceDefinitions<optional>() {
+
+                @Override
+                public <T, R> Functor<optional> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<optional> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<optional> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<optional> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<optional>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<optional>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<optional>> monadPlus(Monoid<Higher<optional, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<optional>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<optional>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<optional>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<optional>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
 
 
         /**
@@ -759,7 +850,7 @@ public static <T,R> MonadZero<optional> monadZero(){
          */
         public static <T> MonadPlus<optional> monadPlus(){
             Monoid<Optional<T>> mn = Monoid.of(Optional.absent(), (a, b) -> a.isPresent() ? a : b);
-            Monoid<OptionalKind<T>> m = Monoid.of(OptionalKind.widen(mn.zero()), (f, g)-> OptionalKind.widen(
+            Monoid<OptionalKind<T>> m = Monoid.of(widen(mn.zero()), (f, g)-> widen(
                     mn.apply(OptionalKind.narrow(f), OptionalKind.narrow(g))));
 
             Monoid<Higher<optional,T>> m2= (Monoid)m;
@@ -781,7 +872,11 @@ public static <T> MonadPlus<optional> monadPlus(){
          * @param m Monoid to use for combining Optionals
          * @return Type class for combining Optionals
          */
-        public static <T> MonadPlus<optional> monadPlus(Monoid<OptionalKind<T>> m){
+        public static <T> MonadPlus<optional> monadPlus(Monoid<Higher<optional,T>> m){
+            Monoid<Higher<optional,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<optional> monadPlusK(Monoid<OptionalKind<T>> m){
             Monoid<Higher<optional,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -820,20 +915,20 @@ public static <T> Comonad<optional> comonad(){
         }
 
         private <T> OptionalKind<T> of(T value){
-            return OptionalKind.widen(Optional.of(value));
+            return widen(Optional.of(value));
         }
         private static <T,R> OptionalKind<R> ap(OptionalKind<Function< T, R>> lt, OptionalKind<T> option){
             Maybe<R> mb = ToCyclopsReact.maybe(lt.narrow()).combine(ToCyclopsReact.maybe(option.narrow()),
                     (a,b)->a.apply(b));
-            return OptionalKind.widen(mb);
+            return widen(mb);
 
         }
         private static <T,R> Higher<optional,R> flatMap(Higher<optional,T> lt, Function<? super T, ? extends  Higher<optional,R>> fn){
-            return OptionalKind.widen(OptionalKind.narrowOptional(lt).flatMap(in->fn.andThen(OptionalKind::narrowOptional).apply(in)));
+            return widen(OptionalKind.narrowOptional(lt).flatMap(in->fn.andThen(OptionalKind::narrowOptional).apply(in)));
         }
         private static <T,R> OptionalKind<R> map(OptionalKind<T> lt, Function<? super T, ? extends R> fn){
 
-            return OptionalKind.widen(OptionalKind.narrow(lt).transform(t->fn.apply(t)));
+            return widen(OptionalKind.narrow(lt).transform(t->fn.apply(t)));
         }
 
 
@@ -845,5 +940,126 @@ private static <C2,T,R> Higher<C2, Higher<optional, R>> traverseA(Applicative<C2
         }
 
     }
+    public static interface Nesteds{
+        public static <T> Nested<optional,fluentIterable,T> fluentIterable(Optional<FluentIterable<T>> nested){
+            OptionalKind<FluentIterable<T>> x = widen(nested);
+            OptionalKind<Higher<fluentIterable,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(), FluentIterables.Instances.definitions());
+        }
+
+
+
+        public static <T> Nested<optional,reactiveSeq,T> reactiveSeq(Optional<ReactiveSeq<T>> nested){
+            OptionalKind<ReactiveSeq<T>> x = widen(nested);
+            OptionalKind<Higher<reactiveSeq,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<optional,maybe,T> maybe(Optional<Maybe<T>> nested){
+            OptionalKind<Maybe<T>> x = widen(nested);
+            OptionalKind<Higher<maybe,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<optional,eval,T> eval(Optional<Eval<T>> nested){
+            OptionalKind<Eval<T>> x = widen(nested);
+            OptionalKind<Higher<eval,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<optional,Witness.future,T> future(Optional<Future<T>> nested){
+            OptionalKind<Future<T>> x = widen(nested);
+            OptionalKind<Higher<Witness.future,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<optional,Higher<xor,S>, P> xor(Optional<Xor<S, P>> nested){
+            OptionalKind<Xor<S, P>> x = widen(nested);
+            OptionalKind<Higher<Higher<xor,S>, P>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<optional,Higher<reader,S>, T> reader(Optional<Reader<S, T>> nested){
+            OptionalKind<Reader<S, T>> x = widen(nested);
+            OptionalKind<Higher<Higher<reader,S>, T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<optional,Higher<Witness.tryType,S>, P> cyclopsTry(Optional<cyclops.control.Try<P, S>> nested){
+            OptionalKind<cyclops.control.Try<P, S>> x = widen(nested);
+            OptionalKind<Higher<Higher<Witness.tryType,S>, P>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<optional,Witness.optional,T> javaOptional(Optional<java.util.Optional<T>> nested){
+            Optional<cyclops.companion.Optionals.OptionalKind<T>> f = nested.transform(o -> cyclops.companion.Optionals.OptionalKind.widen(o));
+            OptionalKind<cyclops.companion.Optionals.OptionalKind<T>> x = widen(f);
+
+            OptionalKind<Higher<Witness.optional,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<optional,completableFuture,T> completableOptional(Optional<CompletableFuture<T>> nested){
+            Optional<CompletableFutureKind<T>> f = nested.transform(o -> CompletableFutureKind.widen(o));
+            OptionalKind<CompletableFutureKind<T>> x = widen(f);
+            OptionalKind<Higher<completableFuture,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<optional,Witness.stream,T> javaStream(Optional<java.util.stream.Stream<T>> nested){
+            Optional<StreamKind<T>> f = nested.transform(o -> StreamKind.widen(o));
+            OptionalKind<StreamKind<T>> x = widen(f);
+            OptionalKind<Higher<Witness.stream,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+        public static interface Reversed{
+            public static <T> Nested<reactiveSeq,optional,T> reactiveSeq(ReactiveSeq<Optional<T>> nested){
+                ReactiveSeq<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+            }
+
+            public static <T> Nested<maybe,optional,T> maybe(Maybe<Optional<T>> nested){
+                Maybe<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<eval,optional,T> eval(Eval<Optional<T>> nested){
+                Eval<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.future,optional,T> future(cyclops.async.Future<Optional<T>> nested){
+                cyclops.async.Future<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+            }
+            public static <S, P> Nested<Higher<xor,S>,optional, P> xor(Xor<S, Optional<P>> nested){
+                Xor<S, Higher<optional,P>> x = nested.map(OptionalKind::widenK);
+
+                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+            }
+            public static <S,T> Nested<Higher<reader,S>,optional, T> reader(Reader<S, Optional<T>> nested){
+
+                Reader<S, Higher<optional, T>>  x = nested.map(OptionalKind::widenK);
+
+                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+            }
+            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,optional, P> cyclopsTry(cyclops.control.Try<Optional<P>, S> nested){
+                cyclops.control.Try<Higher<optional,P>, S> x = nested.map(OptionalKind::widenK);
+
+                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.optional,optional,T> javaOptional(java.util.Optional<Optional<T>> nested){
+                java.util.Optional<Higher<optional, T>> x = nested.map(OptionalKind::widenK);
+
+                return  Nested.of(cyclops.companion.Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+            }
+            public static <T> Nested<completableFuture,optional,T> completableOptional(CompletableFuture<Optional<T>> nested){
+                CompletableFuture<Higher<optional,T>> x = nested.thenApply(OptionalKind::widenK);
+
+                return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+            }
+            public static <T> Nested<Witness.stream,optional,T> javaStream(java.util.stream.Stream<Optional<T>> nested){
+                java.util.stream.Stream<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+                return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+            }
+        }
+
+
+    }
 
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/FluxAdapter.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/FluxAdapter.java
index 62a883dd..d67fd1ef 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/FluxAdapter.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/FluxAdapter.java
@@ -73,4 +73,9 @@ public <T> AnyM<flux, T> unit(T o) {
     public <T> ReactiveSeq<T> toStream(AnyM<flux, T> t) {
         return ReactiveSeq.fromPublisher(ReactorWitness.flux(t));
     }
+
+    @Override
+    public <T, R> AnyM<flux, R> map(AnyM<flux, T> t, Function<? super T, ? extends R> fn) {
+        return Fluxs.anyM(stream(t).map(fn));
+    }
 }
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/MonoAdapter.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/MonoAdapter.java
index e8c50f39..48ccea6a 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/MonoAdapter.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/adapter/MonoAdapter.java
@@ -76,4 +76,8 @@ public <T> ReactiveSeq<T> toStream(AnyM<mono, T> t) {
         return ReactiveSeq.fromPublisher(mono(t));
     }
 
+    @Override
+    public <T, R> AnyM<mono, R> map(AnyM<mono, T> t, Function<? super T, ? extends R> fn) {
+        return Monos.anyM(future(t).map(fn));
+    }
 }
diff --git a/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java b/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java
index a8830486..5c6ecc94 100644
--- a/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java
+++ b/cyclops-rx/src/main/java/com/aol/cyclops/rx/adapter/ObservableAdapter.java
@@ -2,6 +2,7 @@
 
 
 import cyclops.companion.rx.Observables;
+import cyclops.monads.RxWitness;
 import cyclops.monads.RxWitness.observable;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
@@ -68,6 +69,8 @@ public <T> AnyM<observable, T> unit(T o) {
         return Observables.anyM(Observable.just(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<observable, R> map(AnyM<observable, T> t, Function<? super T, ? extends R> fn) {
+        return Observables.anyM(observable(t).map(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/FlowableAdapter.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/FlowableAdapter.java
index aec9f709..1ce62517 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/FlowableAdapter.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/FlowableAdapter.java
@@ -73,4 +73,9 @@ public <T> AnyM<flowable, T> unit(T o) {
     public <T> ReactiveSeq<T> toStream(AnyM<flowable, T> t) {
         return ReactiveSeq.fromPublisher(Rx2Witness.flowable(t));
     }
+
+    @Override
+    public <T, R> AnyM<flowable, R> map(AnyM<flowable, T> t, Function<? super T, ? extends R> fn) {
+        return Flowables.anyM(stream(t).map(i->fn.apply(i)));
+    }
 }
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/MaybeAdapter.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/MaybeAdapter.java
index 9551e5cf..0cf8db99 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/MaybeAdapter.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/MaybeAdapter.java
@@ -5,6 +5,7 @@
 import cyclops.companion.rx2.Functions;
 import cyclops.companion.rx2.Maybes;
 import cyclops.monads.AnyM;
+import cyclops.monads.Rx2Witness;
 import cyclops.monads.Rx2Witness.maybe;
 import cyclops.stream.ReactiveSeq;
 import io.reactivex.Maybe;
@@ -78,4 +79,8 @@ public <T> ReactiveSeq<T> toStream(AnyM<maybe, T> t) {
         return ReactiveSeq.fromPublisher(future(t).toFlowable());
     }
 
+    @Override
+    public <T, R> AnyM<maybe, R> map(AnyM<maybe, T> t, Function<? super T, ? extends R> fn) {
+        return Maybes.anyM(future(t).map(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java
index ca7b6119..8f75f659 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/ObservableAdapter.java
@@ -1,7 +1,9 @@
 package com.aol.cyclops.rx2.adapter;
 
 
+import cyclops.companion.rx2.Flowables;
 import cyclops.companion.rx2.Observables;
+import cyclops.monads.Rx2Witness;
 import cyclops.monads.Rx2Witness.observable;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.monads.AnyM;
@@ -68,6 +70,9 @@ public <T> AnyM<observable, T> unit(T o) {
         return Observables.anyM(Observable.just(o));
     }
 
-
+    @Override
+    public <T, R> AnyM<observable, R> map(AnyM<observable, T> t, Function<? super T, ? extends R> fn) {
+        return Observables.anyM(observable(t).map(i->fn.apply(i)));
+    }
 
 }
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/SingleAdapter.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/SingleAdapter.java
index 17e3767b..6476ebd5 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/SingleAdapter.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/adapter/SingleAdapter.java
@@ -83,4 +83,8 @@ public <T> ReactiveSeq<T> toStream(AnyM<single, T> t) {
         return ReactiveSeq.fromPublisher(future(t).toFlowable());
     }
 
+    @Override
+    public <T, R> AnyM<single, R> map(AnyM<single, T> t, Function<? super T, ? extends R> fn) {
+        return Singles.anyM(future(t).map(x->fn.apply(x)));
+    }
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/EitherAdapter.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/EitherAdapter.java
index 25d43032..66137652 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/EitherAdapter.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/EitherAdapter.java
@@ -4,6 +4,7 @@
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.Vavr;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.either;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.control.Maybe;
@@ -69,6 +70,8 @@ public <T> AnyM<either, T> unit(T o) {
         return Vavr.either(Either.right(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<either, R> map(AnyM<either, T> t, Function<? super T, ? extends R> fn) {
+        return Vavr.either(either(t).map(fn));
+    }
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/FutureAdapter.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/FutureAdapter.java
index 19a5810a..1d48af99 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/FutureAdapter.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/FutureAdapter.java
@@ -5,6 +5,7 @@
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.Vavr;
 
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.future;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.control.Maybe;
@@ -71,6 +72,8 @@ public <T> AnyM<future, T> unit(T o) {
         return Vavr.future(Future.successful(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<future, R> map(AnyM<future, T> t, Function<? super T, ? extends R> fn) {
+        return Vavr.future(future(t).map(fn));
+    }
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/OptionAdapter.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/OptionAdapter.java
index 07913c5f..839dcd8f 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/OptionAdapter.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/OptionAdapter.java
@@ -4,6 +4,7 @@
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.Vavr;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.option;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.control.Maybe;
@@ -68,5 +69,8 @@ public <T> AnyM<option, T> unit(T o) {
     }
 
 
-
+    @Override
+    public <T, R> AnyM<option, R> map(AnyM<option, T> t, Function<? super T, ? extends R> fn) {
+        return Vavr.option(option(t).map(fn));
+    }
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TraversableAdapter.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TraversableAdapter.java
index 8e2cd6e3..b3c681af 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TraversableAdapter.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TraversableAdapter.java
@@ -68,6 +68,8 @@ public <T> AnyM<W, T> unit(T o) {
         return anyM(singletonTraversable(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<W, R> map(AnyM<W, T> t, Function<? super T, ? extends R> fn) {
+        return anyM(stream(t).map(fn));
+    }
 }
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TryAdapter.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TryAdapter.java
index e81a4cce..8384b4f5 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TryAdapter.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/adapter/TryAdapter.java
@@ -4,6 +4,7 @@
 import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.Vavr;
+import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.tryType;
 import com.aol.cyclops2.types.extensability.AbstractFunctionalAdapter;
 import cyclops.control.Maybe;
@@ -67,6 +68,8 @@ public <T> AnyM<tryType, T> unit(T o) {
         return Vavr.tryM(Try.success(o));
     }
 
-
-
+    @Override
+    public <T, R> AnyM<tryType, R> map(AnyM<tryType, T> t, Function<? super T, ? extends R> fn) {
+        return Vavr.tryM(tryType(t).map(fn));
+    }
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
index 4a597039..f2b42705 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
@@ -53,6 +53,7 @@ public static <T,W extends WitnessType<W>> ListT<W, T> liftM(List<T> opt, W witn
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,list,T> xorM(List<T> type){
         return XorM.right(anyM(type));
     }
+
     public static <T> AnyMSeq<list,T> anyM(List<T> option) {
         return AnyM.ofSeq(option, list.INSTANCE);
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index 9b2bdda2..a4a52127 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -670,7 +670,7 @@ public static Unfoldable<stream> unfoldable(){
             return new Unfoldable<stream>() {
                 @Override
                 public <R, T> Higher<stream, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
-                    return widen(ReactiveSeq.unfold(b,fn).collect(Stream.collector()));
+                    return widen(Stream.ofAll((Iterable)ReactiveSeq.unfold(b,fn)));
 
                 }
             };
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java
index cdfd78bd..c4393ef5 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/OptionsTest.java
@@ -108,7 +108,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<OptionKind<Integer>> m = Monoid.of(OptionKind.widen(Option.none()), (a, b)->a.isDefined() ? b : a);
-        OptionKind<Integer> opt = Options.Instances.<Integer>monadPlus(m)
+        OptionKind<Integer> opt = Options.Instances.<Integer>monadPlusK(m)
                                       .plus(OptionKind.widen(Option.of(5)), OptionKind.widen(Option.of(10)))
                                       .convert(OptionKind::narrowK);
         assertThat(opt,equalTo(Option.of(10)));
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java
index 985f2990..d83e3db0 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/QueuesTest.java
@@ -110,7 +110,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<QueueKind<Integer>> m = Monoid.of(QueueKind.widen(Queue.empty()), (a, b)->a.isEmpty() ? b : a);
-        QueueKind<Integer> list = Queues.Instances.<Integer>monadPlus(m)
+        QueueKind<Integer> list = Queues.Instances.<Integer>monadPlusK(m)
                                       .plus(QueueKind.widen(Queue.of(5)), QueueKind.widen(Queue.of(10)))
                                       .convert(QueueKind::narrowK);
         assertThat(list,equalTo(Queue.of(5)));
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java
index f7fa0eeb..d561ffd0 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/VectorsTest.java
@@ -110,7 +110,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<VectorKind<Integer>> m = Monoid.of(VectorKind.widen(Vector.empty()), (a, b)->a.isEmpty() ? b : a);
-        VectorKind<Integer> list = Vectors.Instances.<Integer>monadPlus(m)
+        VectorKind<Integer> list = Vectors.Instances.<Integer>monadPlusK(m)
                                       .plus(VectorKind.widen(Vector.of(5)), VectorKind.widen(Vector.of(10)))
                                       .convert(VectorKind::narrowK);
         assertThat(list,equalTo(Vector.of(5)));
diff --git a/gradle.properties b/gradle.properties
index 42b7d9c1..6299bfbe 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,7 +2,7 @@ version=9.0.0-MI5
 lombokVersion=1.16.2
 cyclopsReactVersion=2.0.0-FINAL
 vavrVersion=0.9.0
-guavaVersion=20.0
+guavaVersion=22.0
 functionalJavaVersion=4.5
 reactiveStreamsVersion=1.0.0
 hamcrestVersion=1.3

From a84507546f5611cf2ea4748cc1abee461bddb0c0 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 13:06:20 +0100
Subject: [PATCH 12/30] Guava migration

---
 .../companion/guava/FluentIterables.java      |  89 ++++++++-------
 .../cyclops/companion/guava/Optionals.java    | 106 +++++++++--------
 .../instances/FluentIterablesTest.java        |  36 +++++-
 .../typeclasses/instances/OptionalsTest.java  |   2 +-
 .../java/cyclops/companion/vavr/Arrays.java   |  85 +++++++-------
 .../java/cyclops/companion/vavr/Eithers.java  |  85 +++++++-------
 .../java/cyclops/companion/vavr/Futures.java  | 107 +++++++++---------
 .../java/cyclops/companion/vavr/Lazys.java    |  86 +++++++-------
 .../java/cyclops/companion/vavr/Lists.java    |  85 +++++++-------
 .../java/cyclops/companion/vavr/Options.java  | 107 +++++++++---------
 .../java/cyclops/companion/vavr/Queues.java   |  85 +++++++-------
 .../java/cyclops/companion/vavr/Sets.java     |  85 +++++++-------
 .../java/cyclops/companion/vavr/Streams.java  |  87 +++++++-------
 .../java/cyclops/companion/vavr/Trys.java     | 107 +++++++++---------
 14 files changed, 598 insertions(+), 554 deletions(-)

diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
index 77228f85..7513a6b0 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
@@ -673,7 +673,7 @@ public <R, T> Higher<fluentIterable, R> unfold(T b, Function<? super T, Optional
         }
     }
 
-    public static interface Nesteds{
+    public static interface FluentIterableNested {
         public static <T> Nested<fluentIterable,GuavaWitness.optional,T> optional(FluentIterable<com.google.common.base.Optional<T>> nested){
             FluentIterableKind<com.google.common.base.Optional<T>> x = widen(nested);
             FluentIterableKind<Higher<GuavaWitness.optional,T>> y = (FluentIterableKind)x;
@@ -725,7 +725,7 @@ public static <T> Nested<fluentIterable,Witness.optional,T> javaOptional(FluentI
             FluentIterableKind<Higher<Witness.optional,T>> y = (FluentIterableKind)x;
             return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
         }
-        public static <T> Nested<fluentIterable,completableFuture,T> completableOptional(FluentIterable<CompletableFuture<T>> nested){
+        public static <T> Nested<fluentIterable,completableFuture,T> javaCompletableFuture(FluentIterable<CompletableFuture<T>> nested){
             FluentIterable<CompletableFutureKind<T>> f = nested.transform(o -> CompletableFutureKind.widen(o));
             FluentIterableKind<CompletableFutureKind<T>> x = FluentIterableKind.widen(f);
             FluentIterableKind<Higher<completableFuture,T>> y = (FluentIterableKind)x;
@@ -739,62 +739,63 @@ public static <T> Nested<fluentIterable,Witness.stream,T> javaStream(FluentItera
         }
 
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,fluentIterable,T> reactiveSeq(ReactiveSeq<FluentIterable<T>> nested){
-                ReactiveSeq<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
 
-            public static <T> Nested<maybe,fluentIterable,T> maybe(Maybe<FluentIterable<T>> nested){
-                Maybe<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
 
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,fluentIterable,T> eval(Eval<FluentIterable<T>> nested){
-                Eval<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
 
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,fluentIterable,T> future(cyclops.async.Future<FluentIterable<T>> nested){
-                cyclops.async.Future<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+    }
 
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,fluentIterable, P> xor(Xor<S, FluentIterable<P>> nested){
-                Xor<S, Higher<fluentIterable,P>> x = nested.map(FluentIterableKind::widenK);
+    public static interface NestedFluentIterable{
+        public static <T> Nested<reactiveSeq,fluentIterable,T> reactiveSeq(ReactiveSeq<FluentIterable<T>> nested){
+            ReactiveSeq<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
 
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,fluentIterable, T> reader(Reader<S, FluentIterable<T>> nested){
+        public static <T> Nested<maybe,fluentIterable,T> maybe(Maybe<FluentIterable<T>> nested){
+            Maybe<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
 
-                Reader<S, Higher<fluentIterable, T>>  x = nested.map(FluentIterableKind::widenK);
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,fluentIterable,T> eval(Eval<FluentIterable<T>> nested){
+            Eval<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
 
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,fluentIterable, P> cyclopsTry(cyclops.control.Try<FluentIterable<P>, S> nested){
-                cyclops.control.Try<Higher<fluentIterable,P>, S> x = nested.map(FluentIterableKind::widenK);
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,fluentIterable,T> future(cyclops.async.Future<FluentIterable<T>> nested){
+            cyclops.async.Future<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
 
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,fluentIterable,T> javaOptional(Optional<FluentIterable<T>> nested){
-                Optional<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,fluentIterable, P> xor(Xor<S, FluentIterable<P>> nested){
+            Xor<S, Higher<fluentIterable,P>> x = nested.map(FluentIterableKind::widenK);
 
-                return  Nested.of(cyclops.companion.Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,fluentIterable,T> completableFluentIterable(CompletableFuture<FluentIterable<T>> nested){
-                CompletableFuture<Higher<fluentIterable,T>> x = nested.thenApply(FluentIterableKind::widenK);
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,fluentIterable, T> reader(Reader<S, FluentIterable<T>> nested){
 
-                return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,fluentIterable,T> javaStream(java.util.stream.Stream<FluentIterable<T>> nested){
-                java.util.stream.Stream<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
+            Reader<S, Higher<fluentIterable, T>>  x = nested.map(FluentIterableKind::widenK);
 
-                return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
         }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,fluentIterable, P> cyclopsTry(cyclops.control.Try<FluentIterable<P>, S> nested){
+            cyclops.control.Try<Higher<fluentIterable,P>, S> x = nested.map(FluentIterableKind::widenK);
 
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,fluentIterable,T> javaOptional(Optional<FluentIterable<T>> nested){
+            Optional<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
 
-    }
+            return  Nested.of(cyclops.companion.Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,fluentIterable,T> javaCompletableFuture(CompletableFuture<FluentIterable<T>> nested){
+            CompletableFuture<Higher<fluentIterable,T>> x = nested.thenApply(FluentIterableKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,fluentIterable,T> javaStream(java.util.stream.Stream<FluentIterable<T>> nested){
+            java.util.stream.Stream<Higher<fluentIterable,T>> x = nested.map(FluentIterableKind::widenK);
 
+            return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 
 }
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
index 167ee757..38c24dbe 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
@@ -940,7 +940,7 @@ private static <C2,T,R> Higher<C2, Higher<optional, R>> traverseA(Applicative<C2
         }
 
     }
-    public static interface Nesteds{
+    public static interface OptionalNested{
         public static <T> Nested<optional,fluentIterable,T> fluentIterable(Optional<FluentIterable<T>> nested){
             OptionalKind<FluentIterable<T>> x = widen(nested);
             OptionalKind<Higher<fluentIterable,T>> y = (OptionalKind)x;
@@ -992,7 +992,7 @@ public static <T> Nested<optional,Witness.optional,T> javaOptional(Optional<java
             OptionalKind<Higher<Witness.optional,T>> y = (OptionalKind)x;
             return Nested.of(y,Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
         }
-        public static <T> Nested<optional,completableFuture,T> completableOptional(Optional<CompletableFuture<T>> nested){
+        public static <T> Nested<optional,completableFuture,T> javaCompletableFuture(Optional<CompletableFuture<T>> nested){
             Optional<CompletableFutureKind<T>> f = nested.transform(o -> CompletableFutureKind.widen(o));
             OptionalKind<CompletableFutureKind<T>> x = widen(f);
             OptionalKind<Higher<completableFuture,T>> y = (OptionalKind)x;
@@ -1005,61 +1005,59 @@ public static <T> Nested<optional,Witness.stream,T> javaStream(Optional<java.uti
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,optional,T> reactiveSeq(ReactiveSeq<Optional<T>> nested){
-                ReactiveSeq<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
-
-            public static <T> Nested<maybe,optional,T> maybe(Maybe<Optional<T>> nested){
-                Maybe<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
-
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,optional,T> eval(Eval<Optional<T>> nested){
-                Eval<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
-
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,optional,T> future(cyclops.async.Future<Optional<T>> nested){
-                cyclops.async.Future<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
-
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,optional, P> xor(Xor<S, Optional<P>> nested){
-                Xor<S, Higher<optional,P>> x = nested.map(OptionalKind::widenK);
-
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,optional, T> reader(Reader<S, Optional<T>> nested){
-
-                Reader<S, Higher<optional, T>>  x = nested.map(OptionalKind::widenK);
-
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,optional, P> cyclopsTry(cyclops.control.Try<Optional<P>, S> nested){
-                cyclops.control.Try<Higher<optional,P>, S> x = nested.map(OptionalKind::widenK);
-
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.optional,optional,T> javaOptional(java.util.Optional<Optional<T>> nested){
-                java.util.Optional<Higher<optional, T>> x = nested.map(OptionalKind::widenK);
-
-                return  Nested.of(cyclops.companion.Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,optional,T> completableOptional(CompletableFuture<Optional<T>> nested){
-                CompletableFuture<Higher<optional,T>> x = nested.thenApply(OptionalKind::widenK);
-
-                return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,optional,T> javaStream(java.util.stream.Stream<Optional<T>> nested){
-                java.util.stream.Stream<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
-
-                return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+    }
+    public static interface NestedOptional{
+        public static <T> Nested<reactiveSeq,optional,T> reactiveSeq(ReactiveSeq<Optional<T>> nested){
+            ReactiveSeq<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,optional,T> maybe(Maybe<Optional<T>> nested){
+            Maybe<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,optional,T> eval(Eval<Optional<T>> nested){
+            Eval<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,optional,T> future(cyclops.async.Future<Optional<T>> nested){
+            cyclops.async.Future<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,optional, P> xor(Xor<S, Optional<P>> nested){
+            Xor<S, Higher<optional,P>> x = nested.map(OptionalKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
         }
+        public static <S,T> Nested<Higher<reader,S>,optional, T> reader(Reader<S, Optional<T>> nested){
 
+            Reader<S, Higher<optional, T>>  x = nested.map(OptionalKind::widenK);
 
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,optional, P> cyclopsTry(cyclops.control.Try<Optional<P>, S> nested){
+            cyclops.control.Try<Higher<optional,P>, S> x = nested.map(OptionalKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.optional,optional,T> javaOptional(java.util.Optional<Optional<T>> nested){
+            java.util.Optional<Higher<optional, T>> x = nested.map(OptionalKind::widenK);
+
+            return  Nested.of(cyclops.companion.Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,optional,T> javaCompletableFuture(CompletableFuture<Optional<T>> nested){
+            CompletableFuture<Higher<optional,T>> x = nested.thenApply(OptionalKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,optional,T> javaStream(java.util.stream.Stream<Optional<T>> nested){
+            java.util.stream.Stream<Higher<optional,T>> x = nested.map(OptionalKind::widenK);
+
+            return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 }
diff --git a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
index d645d114..5ffe207a 100644
--- a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
+++ b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
@@ -6,15 +6,18 @@
 import static org.junit.Assert.assertThat;
 
 import java.util.Arrays;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
 
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.Monoids;
 import cyclops.companion.guava.FluentIterables;
 import com.aol.cyclops.guava.hkt.FluentIterableKind;
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.control.Maybe;
 import cyclops.function.Fn1;
 import cyclops.function.Lambda;
-import cyclops.monads.GuavaWitness;
 import cyclops.monads.GuavaWitness.fluentIterable;
 import cyclops.stream.ReactiveSeq;
 import org.junit.Test;
@@ -22,6 +25,37 @@
 import com.google.common.collect.FluentIterable;
 
 public class FluentIterablesTest {
+    
+    @Test
+    public void nestedOptionalJava(){
+        Higher<fluentIterable, Integer> res = FluentIterables.FluentIterableNested
+                                                            .javaOptional(FluentIterable.of(Optional.of(1)))
+                                                            .map(i -> i * 20)
+                                                            .foldsUnsafe()
+                                                            .foldLeft(Monoids.intMax);
+        FluentIterable<Integer> fi = FluentIterableKind.narrow(res);
+        assertThat(fi.get(0),equalTo(20));
+    }
+    @Test
+    public void nestedStream(){
+        Higher<fluentIterable, Integer> res = FluentIterables.FluentIterableNested
+                .javaStream(FluentIterable.of(Stream.of(1)))
+                .map(i -> i * 20)
+                .foldsUnsafe()
+                .foldLeft(Monoids.intMax);
+        FluentIterable<Integer> fi = FluentIterableKind.narrow(res);
+        assertThat(fi.get(0),equalTo(20));
+    }
+    @Test
+    public void nestedCompletableFuture(){
+        Higher<fluentIterable, Integer> res = FluentIterables.FluentIterableNested
+                .javaCompletableFuture(FluentIterable.of(CompletableFuture.completedFuture(1)))
+                .map(i -> i * 20)
+                .foldsUnsafe()
+                .foldLeft(Monoids.intMax);
+        FluentIterable<Integer> fi = FluentIterableKind.narrow(res);
+        assertThat(fi.get(0),equalTo(20));
+    }
 
     @Test
     public void unit(){
diff --git a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java
index 9d2bc172..67176e1b 100644
--- a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java
+++ b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/OptionalsTest.java
@@ -109,7 +109,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<OptionalKind<Integer>> m = Monoid.of(OptionalKind.widen(Optional.absent()), (a, b)->a.isPresent() ? b : a);
-        OptionalKind<Integer> opt = Optionals.Instances.<Integer>monadPlus(m)
+        OptionalKind<Integer> opt = Optionals.Instances.<Integer>monadPlusK(m)
                                       .plus(OptionalKind.widen(Optional.of(5)), OptionalKind.widen(Optional.of(10)))
                                       .convert(OptionalKind::narrowK);
         assertThat(opt,equalTo(Optional.of(10)));
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
index 4a58c57c..b208357c 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
@@ -665,7 +665,7 @@ private static <T,R> ArrayKind<R> map(ArrayKind<T> lt, Function<? super T, ? ext
         }
     }
 
-    public static interface Nesteds{
+    public static interface ArrayNested{
 
 
         public static <T> Nested<array,option,T> option(Array<Option<T>> type){
@@ -754,62 +754,63 @@ public static <T> Nested<array,Witness.stream,T> javaStream(Array<java.util.stre
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,array,T> reactiveSeq(ReactiveSeq<Array<T>> nested){
-                ReactiveSeq<Higher<array,T>> x = nested.map(ArrayKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
 
-            public static <T> Nested<maybe,array,T> maybe(Maybe<Array<T>> nested){
-                Maybe<Higher<array,T>> x = nested.map(ArrayKind::widenK);
 
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,array,T> eval(Eval<Array<T>> nested){
-                Eval<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+    }
+    public static interface NestedArray{
+        public static <T> Nested<reactiveSeq,array,T> reactiveSeq(ReactiveSeq<Array<T>> nested){
+            ReactiveSeq<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
 
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,array,T> cyclopsFuture(cyclops.async.Future<Array<T>> nested){
-                cyclops.async.Future<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+        public static <T> Nested<maybe,array,T> maybe(Maybe<Array<T>> nested){
+            Maybe<Higher<array,T>> x = nested.map(ArrayKind::widenK);
 
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,array, P> xor(Xor<S, Array<P>> nested){
-                Xor<S, Higher<array,P>> x = nested.map(ArrayKind::widenK);
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,array,T> eval(Eval<Array<T>> nested){
+            Eval<Higher<array,T>> x = nested.map(ArrayKind::widenK);
 
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,array, T> reader(Reader<S, Array<T>> nested){
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,array,T> cyclopsFuture(cyclops.async.Future<Array<T>> nested){
+            cyclops.async.Future<Higher<array,T>> x = nested.map(ArrayKind::widenK);
 
-                Reader<S, Higher<array, T>>  x = nested.map(ArrayKind::widenK);
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,array, P> xor(Xor<S, Array<P>> nested){
+            Xor<S, Higher<array,P>> x = nested.map(ArrayKind::widenK);
 
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,array, P> cyclopsTry(cyclops.control.Try<Array<P>, S> nested){
-                cyclops.control.Try<Higher<array,P>, S> x = nested.map(ArrayKind::widenK);
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,array, T> reader(Reader<S, Array<T>> nested){
 
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,array,T> optional(Optional<Array<T>> nested){
-                Optional<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+            Reader<S, Higher<array, T>>  x = nested.map(ArrayKind::widenK);
 
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,array,T> completableFuture(CompletableFuture<Array<T>> nested){
-                CompletableFuture<Higher<array,T>> x = nested.thenApply(ArrayKind::widenK);
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,array, P> cyclopsTry(cyclops.control.Try<Array<P>, S> nested){
+            cyclops.control.Try<Higher<array,P>, S> x = nested.map(ArrayKind::widenK);
 
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,array,T> javaStream(java.util.stream.Stream<Array<T>> nested){
-                java.util.stream.Stream<Higher<array,T>> x = nested.map(ArrayKind::widenK);
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,array,T> optional(Optional<Array<T>> nested){
+            Optional<Higher<array,T>> x = nested.map(ArrayKind::widenK);
 
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
         }
+        public static <T> Nested<completableFuture,array,T> completableFuture(CompletableFuture<Array<T>> nested){
+            CompletableFuture<Higher<array,T>> x = nested.thenApply(ArrayKind::widenK);
 
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,array,T> javaStream(java.util.stream.Stream<Array<T>> nested){
+            java.util.stream.Stream<Higher<array,T>> x = nested.map(ArrayKind::widenK);
 
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 
+
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
index d823bd98..7e703173 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
@@ -769,7 +769,7 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
             };
         }
 
-        public static interface Nesteds {
+        public static interface EitherNested {
 
 
             public static <L, T> Nested<Higher<either, L>, lazy, T> lazy(Either<L, Lazy<T>> type) {
@@ -872,69 +872,70 @@ public static <L, T> Nested<Higher<either, L>, Witness.stream, T> javaStream(Eit
                 return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
             }
 
-            public static interface Reversed {
-                public static <L, T> Nested<reactiveSeq, Higher<either, L>, T> reactiveSeq(ReactiveSeq<Either<L, T>> nested) {
-                    ReactiveSeq<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
-                    return Nested.of(x, ReactiveSeq.Instances.definitions(), Instances.definitions());
-                }
 
-                public static <L, T> Nested<maybe, Higher<either, L>, T> maybe(Maybe<Either<L, T>> nested) {
-                    Maybe<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
 
-                    return Nested.of(x, Maybe.Instances.definitions(), Instances.definitions());
-                }
 
-                public static <L, T> Nested<eval, Higher<either, L>, T> eval(Eval<Either<L, T>> nested) {
-                    Eval<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+        }
+        public static interface NestedEither {
+            public static <L, T> Nested<reactiveSeq, Higher<either, L>, T> reactiveSeq(ReactiveSeq<Either<L, T>> nested) {
+                ReactiveSeq<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+                return Nested.of(x, ReactiveSeq.Instances.definitions(), Instances.definitions());
+            }
 
-                    return Nested.of(x, Eval.Instances.definitions(), Instances.definitions());
-                }
+            public static <L, T> Nested<maybe, Higher<either, L>, T> maybe(Maybe<Either<L, T>> nested) {
+                Maybe<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
 
-                public static <L, T> Nested<Witness.future, Higher<either, L>, T> cyclopsFuture(cyclops.async.Future<Either<L, T>> nested) {
-                    cyclops.async.Future<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+                return Nested.of(x, Maybe.Instances.definitions(), Instances.definitions());
+            }
 
-                    return Nested.of(x, cyclops.async.Future.Instances.definitions(), Instances.definitions());
-                }
+            public static <L, T> Nested<eval, Higher<either, L>, T> eval(Eval<Either<L, T>> nested) {
+                Eval<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
 
-                public static <L, S, P> Nested<Higher<xor, S>, Higher<either, L>, P> xor(Xor<S, Either<L, P>> nested) {
-                    Xor<S, Higher<Higher<either, L>, P>> x = nested.map(EitherKind::widenK);
+                return Nested.of(x, Eval.Instances.definitions(), Instances.definitions());
+            }
 
-                    return Nested.of(x, Xor.Instances.definitions(), Instances.definitions());
-                }
+            public static <L, T> Nested<Witness.future, Higher<either, L>, T> cyclopsFuture(cyclops.async.Future<Either<L, T>> nested) {
+                cyclops.async.Future<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
 
-                public static <L, S, T> Nested<Higher<reader, S>, Higher<either, L>, T> reader(Reader<S, Either<L, T>> nested) {
+                return Nested.of(x, cyclops.async.Future.Instances.definitions(), Instances.definitions());
+            }
 
-                    Reader<S, Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+            public static <L, S, P> Nested<Higher<xor, S>, Higher<either, L>, P> xor(Xor<S, Either<L, P>> nested) {
+                Xor<S, Higher<Higher<either, L>, P>> x = nested.map(EitherKind::widenK);
 
-                    return Nested.of(x, Reader.Instances.definitions(), Instances.definitions());
-                }
+                return Nested.of(x, Xor.Instances.definitions(), Instances.definitions());
+            }
 
-                public static <L, S extends Throwable, P> Nested<Higher<Witness.tryType, S>, Higher<either, L>, P> cyclopsTry(cyclops.control.Try<Either<L, P>, S> nested) {
-                    cyclops.control.Try<Higher<Higher<either, L>, P>, S> x = nested.map(EitherKind::widenK);
+            public static <L, S, T> Nested<Higher<reader, S>, Higher<either, L>, T> reader(Reader<S, Either<L, T>> nested) {
 
-                    return Nested.of(x, cyclops.control.Try.Instances.definitions(), Instances.definitions());
-                }
+                Reader<S, Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
 
-                public static <L, T> Nested<optional, Higher<either, L>, T> optional(Optional<Either<L, T>> nested) {
-                    Optional<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+                return Nested.of(x, Reader.Instances.definitions(), Instances.definitions());
+            }
 
-                    return Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-                }
+            public static <L, S extends Throwable, P> Nested<Higher<Witness.tryType, S>, Higher<either, L>, P> cyclopsTry(cyclops.control.Try<Either<L, P>, S> nested) {
+                cyclops.control.Try<Higher<Higher<either, L>, P>, S> x = nested.map(EitherKind::widenK);
+
+                return Nested.of(x, cyclops.control.Try.Instances.definitions(), Instances.definitions());
+            }
 
-                public static <L, T> Nested<completableFuture, Higher<either, L>, T> completableFuture(CompletableFuture<Either<L, T>> nested) {
-                    CompletableFuture<Higher<Higher<either, L>, T>> x = nested.thenApply(EitherKind::widenK);
+            public static <L, T> Nested<optional, Higher<either, L>, T> optional(Optional<Either<L, T>> nested) {
+                Optional<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
 
-                    return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(), Instances.definitions());
-                }
+                return Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+            }
 
-                public static <L, T> Nested<Witness.stream, Higher<either, L>, T> javaStream(java.util.stream.Stream<Either<L, T>> nested) {
-                    java.util.stream.Stream<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
+            public static <L, T> Nested<completableFuture, Higher<either, L>, T> completableFuture(CompletableFuture<Either<L, T>> nested) {
+                CompletableFuture<Higher<Higher<either, L>, T>> x = nested.thenApply(EitherKind::widenK);
 
-                    return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(), Instances.definitions());
-                }
+                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(), Instances.definitions());
             }
 
+            public static <L, T> Nested<Witness.stream, Higher<either, L>, T> javaStream(java.util.stream.Stream<Either<L, T>> nested) {
+                java.util.stream.Stream<Higher<Higher<either, L>, T>> x = nested.map(EitherKind::widenK);
 
+                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(), Instances.definitions());
+            }
         }
     }
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
index 0e8b566b..feaa3f6f 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
@@ -1054,7 +1054,7 @@ private static <C2,T,R> Higher<C2, Higher<future, R>> traverseA(Applicative<C2>
 
     }
 
-    public static interface Nesteds{
+    public static interface FutureNested{
 
 
         public static <T> Nested<future,option,T> option(Future<Option<T>> type){
@@ -1143,61 +1143,62 @@ public static <T> Nested<future,Witness.stream,T> javaStream(Future<java.util.st
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,future,T> reactiveSeq(ReactiveSeq<Future<T>> nested){
-                ReactiveSeq<Higher<future,T>> x = nested.map(FutureKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
-
-            public static <T> Nested<maybe,future,T> maybe(Maybe<Future<T>> nested){
-                Maybe<Higher<future,T>> x = nested.map(FutureKind::widenK);
-
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,future,T> eval(Eval<Future<T>> nested){
-                Eval<Higher<future,T>> x = nested.map(FutureKind::widenK);
-
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,future,T> cyclopsFuture(cyclops.async.Future<Future<T>> nested){
-                cyclops.async.Future<Higher<future,T>> x = nested.map(FutureKind::widenK);
-
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,future, P> xor(Xor<S, Future<P>> nested){
-                Xor<S, Higher<future,P>> x = nested.map(FutureKind::widenK);
-
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,future, T> reader(Reader<S, Future<T>> nested){
-
-                Reader<S, Higher<future, T>>  x = nested.map(FutureKind::widenK);
-
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,future, P> cyclopsTry(cyclops.control.Try<Future<P>, S> nested){
-                cyclops.control.Try<Higher<future,P>, S> x = nested.map(FutureKind::widenK);
-
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,future,T> optional(Optional<Future<T>> nested){
-                Optional<Higher<future,T>> x = nested.map(FutureKind::widenK);
-
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,future,T> completableFuture(CompletableFuture<Future<T>> nested){
-                CompletableFuture<Higher<future,T>> x = nested.thenApply(FutureKind::widenK);
-
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,future,T> javaStream(java.util.stream.Stream<Future<T>> nested){
-                java.util.stream.Stream<Higher<future,T>> x = nested.map(FutureKind::widenK);
-
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+
+
+
+    }
+    public static interface NestedFuture{
+        public static <T> Nested<reactiveSeq,future,T> reactiveSeq(ReactiveSeq<Future<T>> nested){
+            ReactiveSeq<Higher<future,T>> x = nested.map(FutureKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,future,T> maybe(Maybe<Future<T>> nested){
+            Maybe<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,future,T> eval(Eval<Future<T>> nested){
+            Eval<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,future,T> cyclopsFuture(cyclops.async.Future<Future<T>> nested){
+            cyclops.async.Future<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
         }
+        public static <S, P> Nested<Higher<xor,S>,future, P> xor(Xor<S, Future<P>> nested){
+            Xor<S, Higher<future,P>> x = nested.map(FutureKind::widenK);
 
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,future, T> reader(Reader<S, Future<T>> nested){
+
+            Reader<S, Higher<future, T>>  x = nested.map(FutureKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,future, P> cyclopsTry(cyclops.control.Try<Future<P>, S> nested){
+            cyclops.control.Try<Higher<future,P>, S> x = nested.map(FutureKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,future,T> optional(Optional<Future<T>> nested){
+            Optional<Higher<future,T>> x = nested.map(FutureKind::widenK);
 
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,future,T> completableFuture(CompletableFuture<Future<T>> nested){
+            CompletableFuture<Higher<future,T>> x = nested.thenApply(FutureKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,future,T> javaStream(java.util.stream.Stream<Future<T>> nested){
+            java.util.stream.Stream<Higher<future,T>> x = nested.map(FutureKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
index 58dbcd69..87184228 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
@@ -781,7 +781,7 @@ private static <C2,T,R> Higher<C2, Higher<lazy, R>> traverseA(Applicative<C2> ap
         }
 
     }
-    public static interface Nesteds{
+    public static interface LazyNested{
 
 
         public static <T> Nested<lazy,option,T> option(Lazy<Option<T>> type){
@@ -870,61 +870,63 @@ public static <T> Nested<lazy,Witness.stream,T> javaStream(Lazy<java.util.stream
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,lazy,T> reactiveSeq(ReactiveSeq<Lazy<T>> nested){
-                ReactiveSeq<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
 
-            public static <T> Nested<maybe,lazy,T> maybe(Maybe<Lazy<T>> nested){
-                Maybe<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
 
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,lazy,T> eval(Eval<Lazy<T>> nested){
-                Eval<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
 
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,lazy,T> cyclopsFuture(cyclops.async.Future<Lazy<T>> nested){
-                cyclops.async.Future<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+    }
+
+    public static interface NestedLazy{
+        public static <T> Nested<reactiveSeq,lazy,T> reactiveSeq(ReactiveSeq<Lazy<T>> nested){
+            ReactiveSeq<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
 
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,lazy, P> xor(Xor<S, Lazy<P>> nested){
-                Xor<S, Higher<lazy,P>> x = nested.map(LazyKind::widenK);
+        public static <T> Nested<maybe,lazy,T> maybe(Maybe<Lazy<T>> nested){
+            Maybe<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
 
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,lazy, T> reader(Reader<S, Lazy<T>> nested){
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,lazy,T> eval(Eval<Lazy<T>> nested){
+            Eval<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,lazy,T> cyclopsFuture(cyclops.async.Future<Lazy<T>> nested){
+            cyclops.async.Future<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
 
-                Reader<S, Higher<lazy, T>>  x = nested.map(LazyKind::widenK);
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,lazy, P> xor(Xor<S, Lazy<P>> nested){
+            Xor<S, Higher<lazy,P>> x = nested.map(LazyKind::widenK);
 
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,lazy, P> cyclopsTry(cyclops.control.Try<Lazy<P>, S> nested){
-                cyclops.control.Try<Higher<lazy,P>, S> x = nested.map(LazyKind::widenK);
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,lazy, T> reader(Reader<S, Lazy<T>> nested){
 
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,lazy,T> optional(Optional<Lazy<T>> nested){
-                Optional<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+            Reader<S, Higher<lazy, T>>  x = nested.map(LazyKind::widenK);
 
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,lazy,T> completableLazy(CompletableFuture<Lazy<T>> nested){
-                CompletableFuture<Higher<lazy,T>> x = nested.thenApply(LazyKind::widenK);
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,lazy, P> cyclopsTry(cyclops.control.Try<Lazy<P>, S> nested){
+            cyclops.control.Try<Higher<lazy,P>, S> x = nested.map(LazyKind::widenK);
 
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,lazy,T> javaStream(java.util.stream.Stream<Lazy<T>> nested){
-                java.util.stream.Stream<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,lazy,T> optional(Optional<Lazy<T>> nested){
+            Optional<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
 
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
         }
+        public static <T> Nested<completableFuture,lazy,T> completableLazy(CompletableFuture<Lazy<T>> nested){
+            CompletableFuture<Higher<lazy,T>> x = nested.thenApply(LazyKind::widenK);
 
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,lazy,T> javaStream(java.util.stream.Stream<Lazy<T>> nested){
+            java.util.stream.Stream<Higher<lazy,T>> x = nested.map(LazyKind::widenK);
 
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
index f2b42705..1a897762 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
@@ -663,7 +663,7 @@ public static  <W1,T> Coproduct<W1,list,T> coproduct(List<T> list, InstanceDefin
         return Coproduct.of(Xor.primary(ListKind.widen(list)),def1, Instances.definitions());
     }
 
-    public static interface Nesteds{
+    public static interface ListNested{
 
 
         public static <T> Nested<list,option,T> option(List<Option<T>> type){
@@ -752,61 +752,62 @@ public static <T> Nested<list,Witness.stream,T> javaStream(List<java.util.stream
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,list,T> reactiveSeq(ReactiveSeq<List<T>> nested){
-                ReactiveSeq<Higher<list,T>> x = nested.map(ListKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
 
-            public static <T> Nested<maybe,list,T> maybe(Maybe<List<T>> nested){
-                Maybe<Higher<list,T>> x = nested.map(ListKind::widenK);
 
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,list,T> eval(Eval<List<T>> nested){
-                Eval<Higher<list,T>> x = nested.map(ListKind::widenK);
+    }
 
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,list,T> cyclopsFuture(cyclops.async.Future<List<T>> nested){
-                cyclops.async.Future<Higher<list,T>> x = nested.map(ListKind::widenK);
+    public static interface NestedList{
+        public static <T> Nested<reactiveSeq,list,T> reactiveSeq(ReactiveSeq<List<T>> nested){
+            ReactiveSeq<Higher<list,T>> x = nested.map(ListKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
 
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,list, P> xor(Xor<S, List<P>> nested){
-                Xor<S, Higher<list,P>> x = nested.map(ListKind::widenK);
+        public static <T> Nested<maybe,list,T> maybe(Maybe<List<T>> nested){
+            Maybe<Higher<list,T>> x = nested.map(ListKind::widenK);
 
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,list, T> reader(Reader<S, List<T>> nested){
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,list,T> eval(Eval<List<T>> nested){
+            Eval<Higher<list,T>> x = nested.map(ListKind::widenK);
 
-                Reader<S, Higher<list, T>>  x = nested.map(ListKind::widenK);
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,list,T> cyclopsFuture(cyclops.async.Future<List<T>> nested){
+            cyclops.async.Future<Higher<list,T>> x = nested.map(ListKind::widenK);
 
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,list, P> cyclopsTry(cyclops.control.Try<List<P>, S> nested){
-                cyclops.control.Try<Higher<list,P>, S> x = nested.map(ListKind::widenK);
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,list, P> xor(Xor<S, List<P>> nested){
+            Xor<S, Higher<list,P>> x = nested.map(ListKind::widenK);
 
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,list,T> optional(Optional<List<T>> nested){
-                Optional<Higher<list,T>> x = nested.map(ListKind::widenK);
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,list, T> reader(Reader<S, List<T>> nested){
 
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,list,T> completableFuture(CompletableFuture<List<T>> nested){
-                CompletableFuture<Higher<list,T>> x = nested.thenApply(ListKind::widenK);
+            Reader<S, Higher<list, T>>  x = nested.map(ListKind::widenK);
 
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,list,T> javaStream(java.util.stream.Stream<List<T>> nested){
-                java.util.stream.Stream<Higher<list,T>> x = nested.map(ListKind::widenK);
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,list, P> cyclopsTry(cyclops.control.Try<List<P>, S> nested){
+            cyclops.control.Try<Higher<list,P>, S> x = nested.map(ListKind::widenK);
 
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
         }
+        public static <T> Nested<optional,list,T> optional(Optional<List<T>> nested){
+            Optional<Higher<list,T>> x = nested.map(ListKind::widenK);
 
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,list,T> completableFuture(CompletableFuture<List<T>> nested){
+            CompletableFuture<Higher<list,T>> x = nested.thenApply(ListKind::widenK);
 
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,list,T> javaStream(java.util.stream.Stream<List<T>> nested){
+            java.util.stream.Stream<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
index 023867fc..5834912a 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
@@ -938,7 +938,7 @@ private static <C2,T,R> Higher<C2, Higher<option, R>> traverseA(Applicative<C2>
         }
 
     }
-    public static interface Nesteds{
+    public static interface OptionNest{
 
 
         public static <T> Nested<option,lazy,T> lazy(Option<Lazy<T>> type){
@@ -1027,62 +1027,63 @@ public static <T> Nested<option,Witness.stream,T> javaStream(Option<java.util.st
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,option,T> reactiveSeq(ReactiveSeq<Option<T>> nested){
-                ReactiveSeq<Higher<option,T>> x = nested.map(OptionKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
-
-            public static <T> Nested<maybe,option,T> maybe(Maybe<Option<T>> nested){
-                Maybe<Higher<option,T>> x = nested.map(OptionKind::widenK);
-
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,option,T> eval(Eval<Option<T>> nested){
-                Eval<Higher<option,T>> x = nested.map(OptionKind::widenK);
-
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,option,T> cyclopsFuture(cyclops.async.Future<Option<T>> nested){
-                cyclops.async.Future<Higher<option,T>> x = nested.map(OptionKind::widenK);
-
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,option, P> xor(Xor<S, Option<P>> nested){
-                Xor<S, Higher<option,P>> x = nested.map(OptionKind::widenK);
-
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,option, T> reader(Reader<S, Option<T>> nested){
-
-                Reader<S, Higher<option, T>>  x = nested.map(OptionKind::widenK);
-
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,option, P> cyclopsTry(cyclops.control.Try<Option<P>, S> nested){
-                cyclops.control.Try<Higher<option,P>, S> x = nested.map(OptionKind::widenK);
-
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,option,T> optional(Optional<Option<T>> nested){
-                Optional<Higher<option,T>> x = nested.map(OptionKind::widenK);
-
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,option,T> completableOption(CompletableFuture<Option<T>> nested){
-                CompletableFuture<Higher<option,T>> x = nested.thenApply(OptionKind::widenK);
-
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,option,T> javaStream(java.util.stream.Stream<Option<T>> nested){
-                java.util.stream.Stream<Higher<option,T>> x = nested.map(OptionKind::widenK);
-
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+
+    }
+    public static interface OptionNested{
+        public static <T> Nested<reactiveSeq,option,T> reactiveSeq(ReactiveSeq<Option<T>> nested){
+            ReactiveSeq<Higher<option,T>> x = nested.map(OptionKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,option,T> maybe(Maybe<Option<T>> nested){
+            Maybe<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,option,T> eval(Eval<Option<T>> nested){
+            Eval<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,option,T> cyclopsFuture(cyclops.async.Future<Option<T>> nested){
+            cyclops.async.Future<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,option, P> xor(Xor<S, Option<P>> nested){
+            Xor<S, Higher<option,P>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
         }
+        public static <S,T> Nested<Higher<reader,S>,option, T> reader(Reader<S, Option<T>> nested){
 
+            Reader<S, Higher<option, T>>  x = nested.map(OptionKind::widenK);
 
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,option, P> cyclopsTry(cyclops.control.Try<Option<P>, S> nested){
+            cyclops.control.Try<Higher<option,P>, S> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,option,T> optional(Optional<Option<T>> nested){
+            Optional<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,option,T> completableOption(CompletableFuture<Option<T>> nested){
+            CompletableFuture<Higher<option,T>> x = nested.thenApply(OptionKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,option,T> javaStream(java.util.stream.Stream<Option<T>> nested){
+            java.util.stream.Stream<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 
+
+
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
index f9c9ce75..2f9f4079 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
@@ -677,7 +677,7 @@ public <R, T> Higher<queue, R> unfold(T b, Function<? super T, Optional<Tuple2<R
     }
 
 
-    public static interface Nesteds{
+    public static interface QueueNested{
 
 
         public static <T> Nested<queue,lazy,T> lazy(Queue<Lazy<T>> type){
@@ -763,61 +763,62 @@ public static <T> Nested<queue,Witness.stream,T> javaStream(Queue<java.util.stre
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,queue,T> reactiveSeq(ReactiveSeq<Queue<T>> nested){
-                ReactiveSeq<Higher<queue,T>> x = nested.map(QueueKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
 
-            public static <T> Nested<maybe,queue,T> maybe(Maybe<Queue<T>> nested){
-                Maybe<Higher<queue,T>> x = nested.map(QueueKind::widenK);
 
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,queue,T> eval(Eval<Queue<T>> nested){
-                Eval<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+    }
 
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,queue,T> cyclopsFuture(cyclops.async.Future<Queue<T>> nested){
-                cyclops.async.Future<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+    public static interface NestedQueue{
+        public static <T> Nested<reactiveSeq,queue,T> reactiveSeq(ReactiveSeq<Queue<T>> nested){
+            ReactiveSeq<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
 
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,queue, P> xor(Xor<S, Queue<P>> nested){
-                Xor<S, Higher<queue,P>> x = nested.map(QueueKind::widenK);
+        public static <T> Nested<maybe,queue,T> maybe(Maybe<Queue<T>> nested){
+            Maybe<Higher<queue,T>> x = nested.map(QueueKind::widenK);
 
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,queue, T> reader(Reader<S, Queue<T>> nested){
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,queue,T> eval(Eval<Queue<T>> nested){
+            Eval<Higher<queue,T>> x = nested.map(QueueKind::widenK);
 
-                Reader<S, Higher<queue, T>>  x = nested.map(QueueKind::widenK);
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,queue,T> cyclopsFuture(cyclops.async.Future<Queue<T>> nested){
+            cyclops.async.Future<Higher<queue,T>> x = nested.map(QueueKind::widenK);
 
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,queue, P> cyclopsTry(cyclops.control.Try<Queue<P>, S> nested){
-                cyclops.control.Try<Higher<queue,P>, S> x = nested.map(QueueKind::widenK);
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,queue, P> xor(Xor<S, Queue<P>> nested){
+            Xor<S, Higher<queue,P>> x = nested.map(QueueKind::widenK);
 
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,queue,T> queueal(Optional<Queue<T>> nested){
-                Optional<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,queue, T> reader(Reader<S, Queue<T>> nested){
 
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,queue,T> completableQueue(CompletableFuture<Queue<T>> nested){
-                CompletableFuture<Higher<queue,T>> x = nested.thenApply(QueueKind::widenK);
+            Reader<S, Higher<queue, T>>  x = nested.map(QueueKind::widenK);
 
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,queue,T> javaStream(java.util.stream.Stream<Queue<T>> nested){
-                java.util.stream.Stream<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,queue, P> cyclopsTry(cyclops.control.Try<Queue<P>, S> nested){
+            cyclops.control.Try<Higher<queue,P>, S> x = nested.map(QueueKind::widenK);
 
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
         }
+        public static <T> Nested<optional,queue,T> queueal(Optional<Queue<T>> nested){
+            Optional<Higher<queue,T>> x = nested.map(QueueKind::widenK);
 
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,queue,T> completableQueue(CompletableFuture<Queue<T>> nested){
+            CompletableFuture<Higher<queue,T>> x = nested.thenApply(QueueKind::widenK);
 
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,queue,T> javaStream(java.util.stream.Stream<Queue<T>> nested){
+            java.util.stream.Stream<Higher<queue,T>> x = nested.map(QueueKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
index 8acc8b13..bebe861b 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
@@ -674,7 +674,7 @@ public <R, T> Higher<set, R> unfold(T b, Function<? super T, Optional<Tuple2<R,
             };
         }
     }
-    public static interface Nesteds{
+    public static interface SetNested{
 
 
         public static <T> Nested<set,lazy,T> lazy(HashSet<Lazy<T>> type){
@@ -760,62 +760,63 @@ public static <T> Nested<set,Witness.stream,T> javaStream(HashSet<java.util.stre
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,set,T> reactiveSeq(ReactiveSeq<HashSet<T>> nested){
-                ReactiveSeq<Higher<set,T>> x = nested.map(SetKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
 
-            public static <T> Nested<maybe,set,T> maybe(Maybe<HashSet<T>> nested){
-                Maybe<Higher<set,T>> x = nested.map(SetKind::widenK);
 
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,set,T> eval(Eval<HashSet<T>> nested){
-                Eval<Higher<set,T>> x = nested.map(SetKind::widenK);
+    }
+    public static interface NestedSet{
+        public static <T> Nested<reactiveSeq,set,T> reactiveSeq(ReactiveSeq<HashSet<T>> nested){
+            ReactiveSeq<Higher<set,T>> x = nested.map(SetKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
 
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,set,T> cyclopsFuture(cyclops.async.Future<HashSet<T>> nested){
-                cyclops.async.Future<Higher<set,T>> x = nested.map(SetKind::widenK);
+        public static <T> Nested<maybe,set,T> maybe(Maybe<HashSet<T>> nested){
+            Maybe<Higher<set,T>> x = nested.map(SetKind::widenK);
 
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,set, P> xor(Xor<S, HashSet<P>> nested){
-                Xor<S, Higher<set,P>> x = nested.map(SetKind::widenK);
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,set,T> eval(Eval<HashSet<T>> nested){
+            Eval<Higher<set,T>> x = nested.map(SetKind::widenK);
 
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,set, T> reader(Reader<S, HashSet<T>> nested){
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,set,T> cyclopsFuture(cyclops.async.Future<HashSet<T>> nested){
+            cyclops.async.Future<Higher<set,T>> x = nested.map(SetKind::widenK);
 
-                Reader<S, Higher<set, T>>  x = nested.map(SetKind::widenK);
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,set, P> xor(Xor<S, HashSet<P>> nested){
+            Xor<S, Higher<set,P>> x = nested.map(SetKind::widenK);
 
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,set, P> cyclopsTry(cyclops.control.Try<HashSet<P>, S> nested){
-                cyclops.control.Try<Higher<set,P>, S> x = nested.map(SetKind::widenK);
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,set, T> reader(Reader<S, HashSet<T>> nested){
 
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,set,T> setal(Optional<HashSet<T>> nested){
-                Optional<Higher<set,T>> x = nested.map(SetKind::widenK);
+            Reader<S, Higher<set, T>>  x = nested.map(SetKind::widenK);
 
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,set,T> completableSet(CompletableFuture<HashSet<T>> nested){
-                CompletableFuture<Higher<set,T>> x = nested.thenApply(SetKind::widenK);
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,set, P> cyclopsTry(cyclops.control.Try<HashSet<P>, S> nested){
+            cyclops.control.Try<Higher<set,P>, S> x = nested.map(SetKind::widenK);
 
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,set,T> javaStream(java.util.stream.Stream<HashSet<T>> nested){
-                java.util.stream.Stream<Higher<set,T>> x = nested.map(SetKind::widenK);
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,set,T> setal(Optional<HashSet<T>> nested){
+            Optional<Higher<set,T>> x = nested.map(SetKind::widenK);
 
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
         }
+        public static <T> Nested<completableFuture,set,T> completableSet(CompletableFuture<HashSet<T>> nested){
+            CompletableFuture<Higher<set,T>> x = nested.thenApply(SetKind::widenK);
 
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,set,T> javaStream(java.util.stream.Stream<HashSet<T>> nested){
+            java.util.stream.Stream<Higher<set,T>> x = nested.map(SetKind::widenK);
 
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 
+
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index a4a52127..1edcb564 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -677,7 +677,7 @@ public <R, T> Higher<stream, R> unfold(T b, Function<? super T, Optional<Tuple2<
         }
     }
 
-    public static interface Nesteds{
+    public static interface StreamNested{
 
 
         public static <T> Nested<stream,lazy,T> lazy(Stream<Lazy<T>> type){
@@ -763,61 +763,62 @@ public static <T> Nested<stream,Witness.stream,T> javaStream(Stream<java.util.st
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,stream,T> reactiveSeq(ReactiveSeq<Stream<T>> nested){
-                ReactiveSeq<Higher<stream,T>> x = nested.map(StreamKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
 
-            public static <T> Nested<maybe,stream,T> maybe(Maybe<Stream<T>> nested){
-                Maybe<Higher<stream,T>> x = nested.map(StreamKind::widenK);
 
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,stream,T> eval(Eval<Stream<T>> nested){
-                Eval<Higher<stream,T>> x = nested.map(StreamKind::widenK);
 
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,stream,T> cyclopsFuture(cyclops.async.Future<Stream<T>> nested){
-                cyclops.async.Future<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+    }
 
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,stream, P> xor(Xor<S, Stream<P>> nested){
-                Xor<S, Higher<stream,P>> x = nested.map(StreamKind::widenK);
+    public static interface NestedStream{
+        public static <T> Nested<reactiveSeq,stream,T> reactiveSeq(ReactiveSeq<Stream<T>> nested){
+            ReactiveSeq<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
 
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,stream, T> reader(Reader<S, Stream<T>> nested){
+        public static <T> Nested<maybe,stream,T> maybe(Maybe<Stream<T>> nested){
+            Maybe<Higher<stream,T>> x = nested.map(StreamKind::widenK);
 
-                Reader<S, Higher<stream, T>>  x = nested.map(StreamKind::widenK);
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,stream,T> eval(Eval<Stream<T>> nested){
+            Eval<Higher<stream,T>> x = nested.map(StreamKind::widenK);
 
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,stream, P> cyclopsTry(cyclops.control.Try<Stream<P>, S> nested){
-                cyclops.control.Try<Higher<stream,P>, S> x = nested.map(StreamKind::widenK);
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,stream,T> cyclopsFuture(cyclops.async.Future<Stream<T>> nested){
+            cyclops.async.Future<Higher<stream,T>> x = nested.map(StreamKind::widenK);
 
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,stream,T> streamal(Optional<Stream<T>> nested){
-                Optional<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,stream, P> xor(Xor<S, Stream<P>> nested){
+            Xor<S, Higher<stream,P>> x = nested.map(StreamKind::widenK);
 
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,stream,T> completableStream(CompletableFuture<Stream<T>> nested){
-                CompletableFuture<Higher<stream,T>> x = nested.thenApply(StreamKind::widenK);
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,stream, T> reader(Reader<S, Stream<T>> nested){
 
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,stream,T> javaStream(java.util.stream.Stream<Stream<T>> nested){
-                java.util.stream.Stream<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+            Reader<S, Higher<stream, T>>  x = nested.map(StreamKind::widenK);
 
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
         }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,stream, P> cyclopsTry(cyclops.control.Try<Stream<P>, S> nested){
+            cyclops.control.Try<Higher<stream,P>, S> x = nested.map(StreamKind::widenK);
 
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,stream,T> streamal(Optional<Stream<T>> nested){
+            Optional<Higher<stream,T>> x = nested.map(StreamKind::widenK);
 
-    }
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,stream,T> completableStream(CompletableFuture<Stream<T>> nested){
+            CompletableFuture<Higher<stream,T>> x = nested.thenApply(StreamKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,stream,T> javaStream(java.util.stream.Stream<Stream<T>> nested){
+            java.util.stream.Stream<Higher<stream,T>> x = nested.map(StreamKind::widenK);
 
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
index f881e43a..35a92ede 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
@@ -918,7 +918,7 @@ private static <C2,T,R> Higher<C2, Higher<tryType, R>> traverseA(Applicative<C2>
 
     }
 
-    public static interface Nesteds{
+    public static interface TryNested{
 
 
         public static <T> Nested<tryType,lazy,T> lazy(Try<Lazy<T>> type){
@@ -1004,62 +1004,63 @@ public static <T> Nested<tryType,Witness.stream,T> javaStream(Try<java.util.stre
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-        public static interface Reversed{
-            public static <T> Nested<reactiveSeq,tryType,T> reactiveSeq(ReactiveSeq<Try<T>> nested){
-                ReactiveSeq<Higher<tryType,T>> x = nested.map(TryKind::widenK);
-                return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
-            }
-
-            public static <T> Nested<maybe,tryType,T> maybe(Maybe<Try<T>> nested){
-                Maybe<Higher<tryType,T>> x = nested.map(TryKind::widenK);
-
-                return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<eval,tryType,T> eval(Eval<Try<T>> nested){
-                Eval<Higher<tryType,T>> x = nested.map(TryKind::widenK);
-
-                return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.future,tryType,T> cyclopsFuture(cyclops.async.Future<Try<T>> nested){
-                cyclops.async.Future<Higher<tryType,T>> x = nested.map(TryKind::widenK);
-
-                return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
-            }
-            public static <S, P> Nested<Higher<xor,S>,tryType, P> xor(Xor<S, Try<P>> nested){
-                Xor<S, Higher<tryType,P>> x = nested.map(TryKind::widenK);
-
-                return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
-            }
-            public static <S,T> Nested<Higher<reader,S>,tryType, T> reader(Reader<S, Try<T>> nested){
-
-                Reader<S, Higher<tryType, T>>  x = nested.map(TryKind::widenK);
-
-                return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
-            }
-            public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,tryType, P> cyclopsTry(cyclops.control.Try<Try<P>, S> nested){
-                cyclops.control.Try<Higher<tryType,P>, S> x = nested.map(TryKind::widenK);
-
-                return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<optional,tryType,T> tryTypeal(Optional<Try<T>> nested){
-                Optional<Higher<tryType,T>> x = nested.map(TryKind::widenK);
-
-                return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
-            }
-            public static <T> Nested<completableFuture,tryType,T> completableTry(CompletableFuture<Try<T>> nested){
-                CompletableFuture<Higher<tryType,T>> x = nested.thenApply(TryKind::widenK);
-
-                return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
-            }
-            public static <T> Nested<Witness.stream,tryType,T> javaStream(java.util.stream.Stream<Try<T>> nested){
-                java.util.stream.Stream<Higher<tryType,T>> x = nested.map(TryKind::widenK);
-
-                return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
-            }
+
+
+    }
+    public static interface NestedTry{
+        public static <T> Nested<reactiveSeq,tryType,T> reactiveSeq(ReactiveSeq<Try<T>> nested){
+            ReactiveSeq<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,tryType,T> maybe(Maybe<Try<T>> nested){
+            Maybe<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,tryType,T> eval(Eval<Try<T>> nested){
+            Eval<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,tryType,T> cyclopsFuture(cyclops.async.Future<Try<T>> nested){
+            cyclops.async.Future<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,tryType, P> xor(Xor<S, Try<P>> nested){
+            Xor<S, Higher<tryType,P>> x = nested.map(TryKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,tryType, T> reader(Reader<S, Try<T>> nested){
+
+            Reader<S, Higher<tryType, T>>  x = nested.map(TryKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
         }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,tryType, P> cyclopsTry(cyclops.control.Try<Try<P>, S> nested){
+            cyclops.control.Try<Higher<tryType,P>, S> x = nested.map(TryKind::widenK);
 
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,tryType,T> tryTypeal(Optional<Try<T>> nested){
+            Optional<Higher<tryType,T>> x = nested.map(TryKind::widenK);
 
+            return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,tryType,T> completableTry(CompletableFuture<Try<T>> nested){
+            CompletableFuture<Higher<tryType,T>> x = nested.thenApply(TryKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,tryType,T> javaStream(java.util.stream.Stream<Try<T>> nested){
+            java.util.stream.Stream<Higher<tryType,T>> x = nested.map(TryKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
     }
 
 
+
 }

From 1f1ce3210e8a7e98e1a2a2c908e3897506a3e9bd Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 13:26:11 +0100
Subject: [PATCH 13/30] Reacto migration

---
 .../companion/guava/FluentIterables.java      |   3 -
 .../com/aol/cyclops/reactor/hkt/FluxKind.java |  25 ++++
 .../java/cyclops/companion/reactor/Fluxs.java | 121 +++++++++++++++---
 3 files changed, 130 insertions(+), 19 deletions(-)

diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
index 7513a6b0..be21518b 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
@@ -40,9 +40,6 @@
 
 import static com.aol.cyclops.guava.hkt.FluentIterableKind.widen;
 
-/**
- * Created by johnmcclean on 26/04/2017.
- */
 public class FluentIterables {
     public static  <W1,T> Coproduct<W1,fluentIterable,T> coproduct(FluentIterable<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java
index 5c3014fa..bf5acf29 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/FluxKind.java
@@ -2,9 +2,15 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.reactor.Fluxs;
 import cyclops.monads.ReactorWitness;
 import cyclops.monads.ReactorWitness.flux;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import org.reactivestreams.Publisher;
@@ -40,6 +46,25 @@ private FluxKind(Flux<T> boxed) {
         this.boxed = boxed;
     }
 
+    public <R> FluxKind<R> fold(Function<? super Flux<?  super T>,? extends Flux<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<flux,T> allTypeclasses(){
+        return Active.of(this, Fluxs.Instances.definitions());
+    }
+
+    public static <T> Higher<flux,T> widenK(final Flux<T> completableList) {
+
+        return new FluxKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<flux,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Fluxs.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> StreamT<W, T> liftM(W witness) {
+        return Fluxs.liftM(boxed,witness);
+    }
 
     
     /**
diff --git a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
index cc383f26..64c7f7b2 100644
--- a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
+++ b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
@@ -2,6 +2,7 @@
 
 import com.aol.cyclops.reactor.adapter.FluxReactiveSeq;
 import com.aol.cyclops2.internal.stream.ReactiveStreamX;
+import cyclops.control.Maybe;
 import cyclops.monads.ReactorWitness;
 import cyclops.monads.ReactorWitness.flux;
 import com.aol.cyclops.reactor.hkt.FluxKind;
@@ -14,20 +15,29 @@
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.*;
 
 import java.time.Duration;
+import java.util.Optional;
 import java.util.concurrent.Callable;
 import java.util.function.*;
 import java.util.stream.Stream;
 
+import static com.aol.cyclops.reactor.hkt.FluxKind.widen;
+
 /**
  * Companion class for working with Reactor Flux types
  * 
@@ -91,7 +101,9 @@ public static <W extends WitnessType<W>,T> AnyM<W,Flux<T>> nestedFlux(StreamT<W,
             return Flux.fromStream(s);
         });
     }
-
+    public static <T,W extends WitnessType<W>> StreamT<W, T> liftM(Flux<T> opt, W witness) {
+        return StreamT.of(witness.adapter().unit(Fluxs.reactiveSeq(opt)));
+    }
     public static <W extends WitnessType<W>,T> StreamT<W,T> liftM(AnyM<W,Flux<T>> nested){
         AnyM<W, ReactiveSeq<T>> monad = nested.map(s -> new FluxReactiveSeq<T>(s));
         return StreamT.of(monad);
@@ -502,16 +514,80 @@ public static <T, R1, R> Flux<R> forEach(Flux<? extends T> value1,
 
     }
 
-
+    public static <T> Active<flux,T> allTypeclasses(Flux<T> type){
+        return Active.of(widen(type), Fluxs.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<flux,W2,R> mapM(Flux<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Flux<Higher<W2, R>> e = type.map(fn);
+        FluxKind<Higher<W2, R>> lk = FluxKind.widen(e);
+        return Nested.of(lk, Fluxs.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Fluxs
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<flux> definitions() {
+            return new InstanceDefinitions<flux>() {
+
+                @Override
+                public <T, R> Functor<flux> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<flux> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<flux> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<flux> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<flux>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<flux>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<flux>> monadPlus(Monoid<Higher<flux, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<flux>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<flux>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<flux>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<flux>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
         /**
          *
          * Transform a flux, mulitplying every element by 2
@@ -653,7 +729,7 @@ public static <T,R> Monad<flux> monad(){
          */
         public static <T,R> MonadZero<flux> monadZero(){
             BiFunction<Higher<flux,T>,Predicate<? super T>,Higher<flux,T>> filter = Instances::filter;
-            Supplier<Higher<flux, T>> zero = ()-> FluxKind.widen(Flux.empty());
+            Supplier<Higher<flux, T>> zero = ()-> widen(Flux.empty());
             return General.<flux,T,R>monadZero(monad(), zero,filter);
         }
         /**
@@ -669,7 +745,7 @@ public static <T,R> MonadZero<flux> monadZero(){
          * @return Type class for combining Fluxs by concatenation
          */
         public static <T> MonadPlus<flux> monadPlus(){
-            Monoid<FluxKind<T>> m = Monoid.of(FluxKind.widen(Flux.<T>empty()), Instances::concat);
+            Monoid<FluxKind<T>> m = Monoid.of(widen(Flux.<T>empty()), Instances::concat);
             Monoid<Higher<flux,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -689,7 +765,11 @@ public static <T> MonadPlus<flux> monadPlus(){
          * @param m Monoid to use for combining Fluxs
          * @return Type class for combining Fluxs
          */
-        public static <T> MonadPlus<flux> monadPlus(Monoid<FluxKind<T>> m){
+        public static <T> MonadPlus<flux> monadPlus(Monoid<Higher<flux,T>> m){
+            Monoid<Higher<flux,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<flux> monadPlusK(Monoid<FluxKind<T>> m){
             Monoid<Higher<flux,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -700,11 +780,11 @@ public static <T> MonadPlus<flux> monadPlus(Monoid<FluxKind<T>> m){
         public static <C2,T> Traverse<flux> traverse(){
             BiFunction<Applicative<C2>,FluxKind<Higher<C2, T>>,Higher<C2, FluxKind<T>>> sequenceFn = (ap, flux) -> {
 
-                Higher<C2,FluxKind<T>> identity = ap.unit(FluxKind.widen(Flux.empty()));
+                Higher<C2,FluxKind<T>> identity = ap.unit(widen(Flux.empty()));
 
-                BiFunction<Higher<C2,FluxKind<T>>,Higher<C2,T>,Higher<C2,FluxKind<T>>> combineToFlux =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> FluxKind.widen(Flux.concat(a,Flux.just(b)))),acc,next);
+                BiFunction<Higher<C2,FluxKind<T>>,Higher<C2,T>,Higher<C2,FluxKind<T>>> combineToFlux =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(Flux.concat(a,Flux.just(b)))),acc,next);
 
-                BinaryOperator<Higher<C2,FluxKind<T>>> combineFluxs = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return FluxKind.widen(Flux.concat(l1.narrow(),l2.narrow()));}),a,b); ;
+                BinaryOperator<Higher<C2,FluxKind<T>>> combineFluxs = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return widen(Flux.concat(l1.narrow(),l2.narrow()));}),a,b); ;
 
                 return ReactiveSeq.fromPublisher(flux).reduce(identity,
                         combineToFlux,
@@ -739,22 +819,31 @@ public static <T> Foldable<flux> foldable(){
         }
 
         private static  <T> FluxKind<T> concat(FluxKind<T> l1, FluxKind<T> l2){
-            return FluxKind.widen(Flux.concat(l1,l2));
+            return widen(Flux.concat(l1,l2));
         }
         private static <T> FluxKind<T> of(T value){
-            return FluxKind.widen(Flux.just(value));
+            return widen(Flux.just(value));
         }
         private static <T,R> FluxKind<R> ap(FluxKind<Function< T, R>> lt, FluxKind<T> flux){
-            return FluxKind.widen(lt.zipWith(flux,(a, b)->a.apply(b)));
+            return widen(lt.zipWith(flux,(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<flux,R> flatMap(Higher<flux,T> lt, Function<? super T, ? extends  Higher<flux,R>> fn){
-            return FluxKind.widen(FluxKind.narrowK(lt).flatMap(fn.andThen(FluxKind::narrowK)));
+            return widen(FluxKind.narrowK(lt).flatMap(fn.andThen(FluxKind::narrowK)));
         }
         private static <T,R> FluxKind<R> map(FluxKind<T> lt, Function<? super T, ? extends R> fn){
-            return FluxKind.widen(lt.map(fn));
+            return widen(lt.map(fn));
         }
         private static <T> FluxKind<T> filter(Higher<flux,T> lt, Predicate<? super T> fn){
-            return FluxKind.widen(FluxKind.narrow(lt).filter(fn));
+            return widen(FluxKind.narrow(lt).filter(fn));
+        }
+        public static Unfoldable<flux> unfoldable(){
+            return new Unfoldable<flux>() {
+                @Override
+                public <R, T> Higher<flux, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return widen(Flux.from(ReactiveSeq.unfold(b,fn)));
+
+                }
+            };
         }
     }
 

From 978a39bd0b82aade9e8c548c5af6f461538c40e9 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 13:31:26 +0100
Subject: [PATCH 14/30] Reactor migration

---
 .../companion/guava/FluentIterables.java      |   3 +-
 .../cyclops/companion/guava/Optionals.java    |   2 +
 .../java/cyclops/companion/reactor/Fluxs.java | 140 ++++++++++++++++++
 3 files changed, 144 insertions(+), 1 deletion(-)

diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
index be21518b..c0bfff6c 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
@@ -672,7 +672,8 @@ public <R, T> Higher<fluentIterable, R> unfold(T b, Function<? super T, Optional
 
     public static interface FluentIterableNested {
         public static <T> Nested<fluentIterable,GuavaWitness.optional,T> optional(FluentIterable<com.google.common.base.Optional<T>> nested){
-            FluentIterableKind<com.google.common.base.Optional<T>> x = widen(nested);
+            FluentIterable<OptionalKind<T>> f = nested.transform(o -> OptionalKind.widen(o));
+            FluentIterableKind<OptionalKind<T>> x = widen(f);
             FluentIterableKind<Higher<GuavaWitness.optional,T>> y = (FluentIterableKind)x;
             return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
         }
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
index 38c24dbe..f9c92e7d 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
@@ -942,6 +942,8 @@ private static <C2,T,R> Higher<C2, Higher<optional, R>> traverseA(Applicative<C2
     }
     public static interface OptionalNested{
         public static <T> Nested<optional,fluentIterable,T> fluentIterable(Optional<FluentIterable<T>> nested){
+
+            Optional<FluentIterableKind<T>> f = nested.transform(o -> FluentIterableKind.widen(o));
             OptionalKind<FluentIterable<T>> x = widen(nested);
             OptionalKind<Higher<fluentIterable,T>> y = (OptionalKind)x;
             return Nested.of(y,Instances.definitions(), FluentIterables.Instances.definitions());
diff --git a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
index 64c7f7b2..685c182d 100644
--- a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
+++ b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
@@ -1,8 +1,17 @@
 package cyclops.companion.reactor;
 
 import com.aol.cyclops.reactor.adapter.FluxReactiveSeq;
+import com.aol.cyclops.reactor.hkt.MonoKind;
 import com.aol.cyclops2.internal.stream.ReactiveStreamX;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.companion.Streams;
+import cyclops.companion.Streams.StreamKind;
+import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.monads.ReactorWitness;
 import cyclops.monads.ReactorWitness.flux;
 import com.aol.cyclops.reactor.hkt.FluxKind;
@@ -12,6 +21,9 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.ReactorWitness.mono;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
@@ -33,6 +45,7 @@
 import java.time.Duration;
 import java.util.Optional;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.*;
 import java.util.stream.Stream;
 
@@ -847,5 +860,132 @@ public <R, T> Higher<flux, R> unfold(T b, Function<? super T, Optional<Tuple2<R,
         }
     }
 
+    public static interface FluxNested {
+        public static <T> Nested<flux,mono,T> mono(Flux<Mono<T>> nested){
+            Flux<MonoKind<T>> f = nested.map(MonoKind::widen);
+            FluxKind<MonoKind<T>> x = widen(f);
+            FluxKind<Higher<mono,T>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(), Monos.Instances.definitions());
+        }
+
+
+
+        public static <T> Nested<flux,reactiveSeq,T> reactiveSeq(Flux<ReactiveSeq<T>> nested){
+            FluxKind<ReactiveSeq<T>> x = widen(nested);
+            FluxKind<Higher<reactiveSeq,T>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<flux,Witness.maybe,T> maybe(Flux<Maybe<T>> nested){
+            FluxKind<Maybe<T>> x = widen(nested);
+            FluxKind<Higher<Witness.maybe,T>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<flux,Witness.eval,T> eval(Flux<Eval<T>> nested){
+            FluxKind<Eval<T>> x = widen(nested);
+            FluxKind<Higher<Witness.eval,T>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<flux,Witness.future,T> future(Flux<cyclops.async.Future<T>> nested){
+            FluxKind<cyclops.async.Future<T>> x = widen(nested);
+            FluxKind<Higher<Witness.future,T>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<flux,Higher<xor,S>, P> xor(Flux<Xor<S, P>> nested){
+            FluxKind<Xor<S, P>> x = widen(nested);
+            FluxKind<Higher<Higher<xor,S>, P>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<flux,Higher<reader,S>, T> reader(Flux<Reader<S, T>> nested){
+            FluxKind<Reader<S, T>> x = widen(nested);
+            FluxKind<Higher<Higher<reader,S>, T>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<flux,Higher<Witness.tryType,S>, P> cyclopsTry(Flux<cyclops.control.Try<P, S>> nested){
+            FluxKind<cyclops.control.Try<P, S>> x = widen(nested);
+            FluxKind<Higher<Higher<Witness.tryType,S>, P>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<flux,optional,T> javaOptional(Flux<Optional<T>> nested){
+            Flux<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            FluxKind<OptionalKind<T>> x = FluxKind.widen(f);
+
+            FluxKind<Higher<optional,T>> y = (FluxKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<flux,completableFuture,T> javaCompletableFuture(Flux<CompletableFuture<T>> nested){
+            Flux<CompletableFutureKind<T>> f = nested.map(o -> CompletableFutureKind.widen(o));
+            FluxKind<CompletableFutureKind<T>> x = FluxKind.widen(f);
+            FluxKind<Higher<completableFuture,T>> y = (FluxKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<flux,Witness.stream,T> javaStream(Flux<java.util.stream.Stream<T>> nested){
+            Flux<StreamKind<T>> f = nested.map(o -> StreamKind.widen(o));
+            FluxKind<StreamKind<T>> x = FluxKind.widen(f);
+            FluxKind<Higher<Witness.stream,T>> y = (FluxKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+
+
+
+
+    }
+
+    public static interface NestedFlux{
+        public static <T> Nested<reactiveSeq,flux,T> reactiveSeq(ReactiveSeq<Flux<T>> nested){
+            ReactiveSeq<Higher<flux,T>> x = nested.map(FluxKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,flux,T> maybe(Maybe<Flux<T>> nested){
+            Maybe<Higher<flux,T>> x = nested.map(FluxKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,flux,T> eval(Eval<Flux<T>> nested){
+            Eval<Higher<flux,T>> x = nested.map(FluxKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,flux,T> future(cyclops.async.Future<Flux<T>> nested){
+            cyclops.async.Future<Higher<flux,T>> x = nested.map(FluxKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,flux, P> xor(Xor<S, Flux<P>> nested){
+            Xor<S, Higher<flux,P>> x = nested.map(FluxKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,flux, T> reader(Reader<S, Flux<T>> nested){
+
+            Reader<S, Higher<flux, T>>  x = nested.map(FluxKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,flux, P> cyclopsTry(cyclops.control.Try<Flux<P>, S> nested){
+            cyclops.control.Try<Higher<flux,P>, S> x = nested.map(FluxKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,flux,T> javaOptional(Optional<Flux<T>> nested){
+            Optional<Higher<flux,T>> x = nested.map(FluxKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,flux,T> javaCompletableFuture(CompletableFuture<Flux<T>> nested){
+            CompletableFuture<Higher<flux,T>> x = nested.thenApply(FluxKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,flux,T> javaStream(java.util.stream.Stream<Flux<T>> nested){
+            java.util.stream.Stream<Higher<flux,T>> x = nested.map(FluxKind::widenK);
+
+            return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
+
+
 
 }

From be19ef1300958e6a88b0b8082f7eef36482f64f4 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 13:42:31 +0100
Subject: [PATCH 15/30] more Reactor migration

---
 .../com/aol/cyclops/reactor/hkt/MonoKind.java |  30 ++-
 .../java/cyclops/companion/reactor/Fluxs.java |  12 +-
 .../java/cyclops/companion/reactor/Monos.java | 242 +++++++++++++++++-
 3 files changed, 267 insertions(+), 17 deletions(-)

diff --git a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java
index 95070f13..ed96dd4f 100644
--- a/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java
+++ b/cyclops-reactor/src/main/java/com/aol/cyclops/reactor/hkt/MonoKind.java
@@ -13,8 +13,17 @@
 
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.async.Future;
+import cyclops.companion.reactor.Fluxs;
+import cyclops.companion.reactor.Monos;
 import cyclops.monads.ReactorWitness;
 import cyclops.monads.ReactorWitness.mono;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.FutureT;
+import cyclops.monads.transformers.StreamT;
+import cyclops.monads.transformers.reactor.MonoT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
@@ -50,7 +59,26 @@ private MonoKind(Mono<T> boxed) {
     }
 
 
-    
+    public <R> MonoKind<R> fold(Function<? super Mono<?  super T>,? extends Mono<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<mono,T> allTypeclasses(){
+        return Active.of(this, Monos.Instances.definitions());
+    }
+
+    public static <T> Higher<mono,T> widenK(final Mono<T> completableList) {
+
+        return new MonoKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<ReactorWitness.mono,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Monos.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> MonoT<W, T> liftM(W witness) {
+        return Monos.liftM(boxed,witness);
+    }
+
     /**
      * Construct a HKT encoded completed Mono
      * 
diff --git a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
index 685c182d..574c1598 100644
--- a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
+++ b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Fluxs.java
@@ -867,8 +867,12 @@ public static <T> Nested<flux,mono,T> mono(Flux<Mono<T>> nested){
             FluxKind<Higher<mono,T>> y = (FluxKind)x;
             return Nested.of(y,Instances.definitions(), Monos.Instances.definitions());
         }
-
-
+        public static <T> Nested<flux,flux,T> flux(Flux<Flux<T>> nested){
+            Flux<FluxKind<T>> f = nested.map(FluxKind::widen);
+            FluxKind<FluxKind<T>> x = widen(f);
+            FluxKind<Higher<flux,T>> y = (FluxKind)x;
+            return Nested.of(y,Instances.definitions(), Fluxs.Instances.definitions());
+        }
 
         public static <T> Nested<flux,reactiveSeq,T> reactiveSeq(Flux<ReactiveSeq<T>> nested){
             FluxKind<ReactiveSeq<T>> x = widen(nested);
@@ -926,10 +930,6 @@ public static <T> Nested<flux,Witness.stream,T> javaStream(Flux<java.util.stream
             return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
-
-
-
-
     }
 
     public static interface NestedFlux{
diff --git a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
index d2c05e8f..239002c1 100644
--- a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
+++ b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
@@ -1,19 +1,29 @@
 package cyclops.companion.reactor;
 
 import java.util.Iterator;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
-import com.aol.cyclops.reactor.adapter.FluxReactiveSeq;
+import com.aol.cyclops.reactor.hkt.FluxKind;
 import com.aol.cyclops2.react.Status;
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Optionals;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.companion.Streams;
+import cyclops.companion.Streams.StreamKind;
 import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.control.lazy.Either;
 import cyclops.monads.ReactorWitness;
+import cyclops.monads.ReactorWitness.flux;
 import cyclops.monads.ReactorWitness.mono;
 import com.aol.cyclops.reactor.hkt.MonoKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -24,13 +34,19 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.StreamT;
 import cyclops.monads.transformers.reactor.MonoT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
@@ -42,6 +58,9 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import static com.aol.cyclops.reactor.hkt.MonoKind.widen;
+import static cyclops.companion.Streams.StreamKind.*;
+
 /**
  * Companion class for working with Reactor Mono types
  * 
@@ -59,6 +78,9 @@ public static <T> Mono<T> raw(AnyM<mono,T> anyM){
     public static <W extends WitnessType<W>,T> MonoT<W,T> liftM(AnyM<W,Mono<T>> nested){
         return MonoT.of(nested);
     }
+    public static <T,W extends WitnessType<W>> MonoT<W, T> liftM(Mono<T> opt, W witness) {
+        return MonoT.of(witness.adapter().unit(opt));
+    }
 
     public static <T> Future[] futures(Mono<T>... futures){
 
@@ -438,16 +460,80 @@ public static <T> Iterator<T> iterator(Mono<T> pub) {
     public static <R> Mono<R> narrow(Mono<? extends R> apply) {
         return (Mono<R>)apply;
     }
-
+    public static <T> Active<mono,T> allTypeclasses(Mono<T> type){
+        return Active.of(widen(type), Monos.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<mono,W2,R> mapM(Mono<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Mono<Higher<W2, R>> e = type.map(fn);
+        MonoKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, Monos.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Monos
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<mono> definitions() {
+            return new InstanceDefinitions<mono>() {
+
+                @Override
+                public <T, R> Functor<mono> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<mono> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<mono> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<mono> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<mono>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<mono>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<mono>> monadPlus(Monoid<Higher<mono, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<mono>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<mono>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<mono>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<mono>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
         /**
          *
          * Transform a Mono, mulitplying every element by 2
@@ -609,7 +695,7 @@ public static <T> MonadPlus<mono> monadPlus(){
 
 
             Monoid<MonoKind<T>> m = Monoid.of(MonoKind.<T>widen(Mono.empty()),
-                    (f,g)-> MonoKind.widen(Mono.first(f.narrow(),g.narrow())));
+                    (f,g)-> widen(Mono.first(f.narrow(),g.narrow())));
 
             Monoid<Higher<mono,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
@@ -630,7 +716,12 @@ public static <T> MonadPlus<mono> monadPlus(){
          * @param m Monoid to use for combining Monos
          * @return Type class for combining Monos
          */
-        public static <T> MonadPlus<mono> monadPlus(Monoid<MonoKind<T>> m){
+        public static <T> MonadPlus<mono> monadPlusK(Monoid<MonoKind<T>> m){
+            Monoid<Higher<mono,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+
+        public static <T> MonadPlus<mono> monadPlus(Monoid<Higher<mono,T>> m){
             Monoid<Higher<mono,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -669,19 +760,19 @@ public static <T> Comonad<mono> comonad(){
         }
 
         private static <T> MonoKind<T> of(T value){
-            return MonoKind.widen(Mono.just(value));
+            return widen(Mono.just(value));
         }
         private static <T,R> MonoKind<R> ap(MonoKind<Function< T, R>> lt, MonoKind<T> list){
 
 
-            return MonoKind.widen(Monos.combine(lt.narrow(),list.narrow(), (a, b)->a.apply(b)));
+            return widen(Monos.combine(lt.narrow(),list.narrow(), (a, b)->a.apply(b)));
 
         }
         private static <T,R> Higher<mono,R> flatMap(Higher<mono,T> lt, Function<? super T, ? extends  Higher<mono,R>> fn){
-            return MonoKind.widen(MonoKind.narrow(lt).flatMap(fn.andThen(MonoKind::narrow)));
+            return widen(MonoKind.narrow(lt).flatMap(fn.andThen(MonoKind::narrow)));
         }
         private static <T,R> MonoKind<R> map(MonoKind<T> lt, Function<? super T, ? extends R> fn){
-            return MonoKind.widen(lt.narrow().map(fn));
+            return widen(lt.narrow().map(fn));
         }
 
 
@@ -693,4 +784,135 @@ private static <C2,T,R> Higher<C2, Higher<mono, R>> traverseA(Applicative<C2> ap
 
     }
 
+    public static interface MonoNested {
+        public static <T> Nested<mono,mono,T> mono(Mono<Mono<T>> nested){
+            Mono<MonoKind<T>> f = nested.map(MonoKind::widen);
+            MonoKind<MonoKind<T>> x = widen(f);
+            MonoKind<Higher<mono,T>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(), Monos.Instances.definitions());
+        }
+        public static <T> Nested<mono,flux,T> flux(Mono<Flux<T>> nested){
+            Mono<FluxKind<T>> f = nested.map(FluxKind::widen);
+            MonoKind<FluxKind<T>> x = widen(f);
+            MonoKind<Higher<flux,T>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(), Fluxs.Instances.definitions());
+        }
+
+
+        public static <T> Nested<mono,reactiveSeq,T> reactiveSeq(Mono<ReactiveSeq<T>> nested){
+            MonoKind<ReactiveSeq<T>> x = widen(nested);
+            MonoKind<Higher<reactiveSeq,T>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<mono,maybe,T> maybe(Mono<Maybe<T>> nested){
+            MonoKind<Maybe<T>> x = widen(nested);
+            MonoKind<Higher<maybe,T>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<mono,Witness.eval,T> eval(Mono<Eval<T>> nested){
+            MonoKind<Eval<T>> x = widen(nested);
+            MonoKind<Higher<Witness.eval,T>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<mono,Witness.future,T> future(Mono<cyclops.async.Future<T>> nested){
+            MonoKind<cyclops.async.Future<T>> x = widen(nested);
+            MonoKind<Higher<Witness.future,T>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<mono,Higher<xor,S>, P> xor(Mono<Xor<S, P>> nested){
+            MonoKind<Xor<S, P>> x = widen(nested);
+            MonoKind<Higher<Higher<xor,S>, P>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<mono,Higher<reader,S>, T> reader(Mono<Reader<S, T>> nested){
+            MonoKind<Reader<S, T>> x = widen(nested);
+            MonoKind<Higher<Higher<reader,S>, T>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<mono,Higher<Witness.tryType,S>, P> cyclopsTry(Mono<cyclops.control.Try<P, S>> nested){
+            MonoKind<cyclops.control.Try<P, S>> x = widen(nested);
+            MonoKind<Higher<Higher<Witness.tryType,S>, P>> y = (MonoKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<mono,optional,T> javaOptional(Mono<Optional<T>> nested){
+            Mono<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            MonoKind<OptionalKind<T>> x = MonoKind.widen(f);
+
+            MonoKind<Higher<optional,T>> y = (MonoKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<mono,completableFuture,T> javaCompletableFuture(Mono<CompletableFuture<T>> nested){
+            Mono<CompletableFutureKind<T>> f = nested.map(o -> CompletableFutureKind.widen(o));
+            MonoKind<CompletableFutureKind<T>> x = MonoKind.widen(f);
+            MonoKind<Higher<completableFuture,T>> y = (MonoKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<mono,Witness.stream,T> javaStream(Mono<java.util.stream.Stream<T>> nested){
+            Mono<StreamKind<T>> f = nested.map(o -> StreamKind.widen(o));
+            MonoKind<StreamKind<T>> x = MonoKind.widen(f);
+            MonoKind<Higher<Witness.stream,T>> y = (MonoKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+
+
+
+
+    }
+
+    public static interface NestedMono{
+        public static <T> Nested<reactiveSeq,mono,T> reactiveSeq(ReactiveSeq<Mono<T>> nested){
+            ReactiveSeq<Higher<mono,T>> x = nested.map(MonoKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,mono,T> maybe(Maybe<Mono<T>> nested){
+            Maybe<Higher<mono,T>> x = nested.map(MonoKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.eval,mono,T> eval(Eval<Mono<T>> nested){
+            Eval<Higher<mono,T>> x = nested.map(MonoKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,mono,T> future(cyclops.async.Future<Mono<T>> nested){
+            cyclops.async.Future<Higher<mono,T>> x = nested.map(MonoKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,mono, P> xor(Xor<S, Mono<P>> nested){
+            Xor<S, Higher<mono,P>> x = nested.map(MonoKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,mono, T> reader(Reader<S, Mono<T>> nested){
+
+            Reader<S, Higher<mono, T>>  x = nested.map(MonoKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,mono, P> cyclopsTry(cyclops.control.Try<Mono<P>, S> nested){
+            cyclops.control.Try<Higher<mono,P>, S> x = nested.map(MonoKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<W1, W2, T> javaOptional(Optional<Mono<T>> nested){
+            Optional<Higher<mono,T>> x = nested.map(MonoKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,mono,T> javaCompletableFuture(CompletableFuture<Mono<T>> nested){
+            CompletableFuture<Higher<mono,T>> x = nested.thenApply(MonoKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,mono,T> javaStream(java.util.stream.Stream<Mono<T>> nested){
+            java.util.stream.Stream<Higher<mono,T>> x = nested.map(MonoKind::widenK);
+
+            return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
+
 }

From 07d4e12d34fea843b4d471b57063e1a4ca535c61 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 14:19:26 +0100
Subject: [PATCH 16/30] Rx migration

---
 .../java/cyclops/companion/reactor/Monos.java |   2 +-
 .../aol/cyclops/rx/hkt/ObservableKind.java    |  33 ++-
 .../cyclops/companion/rx/Observables.java     | 252 ++++++++++++++++--
 3 files changed, 264 insertions(+), 23 deletions(-)

diff --git a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
index 239002c1..da1fbd21 100644
--- a/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
+++ b/cyclops-reactor/src/main/java/cyclops/companion/reactor/Monos.java
@@ -898,7 +898,7 @@ public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,mono, P>
 
             return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
         }
-        public static <T> Nested<W1, W2, T> javaOptional(Optional<Mono<T>> nested){
+        public static <T> Nested<optional, mono, T> javaOptional(Optional<Mono<T>> nested){
             Optional<Higher<mono,T>> x = nested.map(MonoKind::widenK);
 
             return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
diff --git a/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java b/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
index fc9caf84..bc9724d4 100644
--- a/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
+++ b/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
@@ -4,10 +4,16 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.monads.RxWitness;
 import cyclops.monads.RxWitness.observable;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.StreamT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
@@ -52,15 +58,28 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final class ObservableKind<T> implements Higher<observable, T>, Publisher<T> {
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
+
+    public <R> ObservableKind<R> fold(Function<? super Observable<?  super T>,? extends Observable<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<observable,T> allTypeclasses(){
+        return Active.of(this, Observables.Instances.definitions());
+    }
+
+    public static <T> Higher<observable,T> widenK(final Observable<T> completableList) {
+
+        return new ObservableKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<observable,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Observables.mapM(boxed,fn,defs);
     }
 
+    public <W extends WitnessType<W>> StreamT<W, T> liftM(W witness) {
+        return Observables.reactiveSeq(boxed).liftM(witness);
+    }
+
+
     /**
      * Construct a HKT encoded completed Observable
      * 
diff --git a/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java b/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java
index 5cd592fc..abd9ea3f 100644
--- a/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java
+++ b/cyclops-rx/src/main/java/cyclops/companion/rx/Observables.java
@@ -1,11 +1,23 @@
 package cyclops.companion.rx;
 
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.function.*;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
 import com.aol.cyclops.rx.adapter.ObservableReactiveSeq;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Optionals;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.companion.Streams;
+import cyclops.companion.Streams.StreamKind;
+import cyclops.control.Eval;
+import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.monads.RxWitness;
 import cyclops.monads.RxWitness.observable;
 import com.aol.cyclops.rx.hkt.ObservableKind;
@@ -15,18 +27,26 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
 
 
 import cyclops.stream.Spouts;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 import org.reactivestreams.Publisher;
 import rx.*;
 import rx.Observable;
@@ -36,6 +56,8 @@
 import rx.observables.SyncOnSubscribe;
 import rx.schedulers.Schedulers;
 
+import static com.aol.cyclops.rx.hkt.ObservableKind.widen;
+
 /**
  * Companion class for working with RxJava Observable types
  * 
@@ -638,16 +660,81 @@ public static <T, R1, R> Observable<R> forEach(Observable<? extends T> value1,
         });
 
     }
-
+    public static <T> Active<observable,T> allTypeclasses(Observable<T> type){
+        return Active.of(widen(type), Observables.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<observable,W2,R> mapM(Observable<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Observable<Higher<W2, R>> e = type.map(x->fn.apply(x));
+        ObservableKind<Higher<W2, R>> lk = ObservableKind.widen(e);
+        return Nested.of(lk, Observables.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Observables
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<observable> definitions() {
+            return new InstanceDefinitions<observable>() {
+
+
+                @Override
+                public <T, R> Functor<observable> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<observable> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<observable> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<observable> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<observable>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<observable>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<observable>> monadPlus(Monoid<Higher<observable, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<observable>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<observable>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<observable>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<observable>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
         /**
          *
          * Transform a observable, mulitplying every element by 2
@@ -788,7 +875,7 @@ public static <T,R> Monad<observable> monad(){
          */
         public static <T,R> MonadZero<observable> monadZero(){
             BiFunction<Higher<observable,T>,Predicate<? super T>,Higher<observable,T>> filter = Instances::filter;
-            Supplier<Higher<observable, T>> zero = ()-> ObservableKind.widen(Observable.empty());
+            Supplier<Higher<observable, T>> zero = ()-> widen(Observable.empty());
             return General.<observable,T,R>monadZero(monad(), zero,filter);
         }
         /**
@@ -804,7 +891,7 @@ public static <T,R> MonadZero<observable> monadZero(){
          * @return Type class for combining Observables by concatenation
          */
         public static <T> MonadPlus<observable> monadPlus(){
-            Monoid<ObservableKind<T>> m = Monoid.of(ObservableKind.widen(Observable.<T>empty()), Instances::concat);
+            Monoid<ObservableKind<T>> m = Monoid.of(widen(Observable.<T>empty()), Instances::concat);
             Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -824,7 +911,11 @@ public static <T> MonadPlus<observable> monadPlus(){
          * @param m Monoid to use for combining Observables
          * @return Type class for combining Observables
          */
-        public static <T> MonadPlus<observable> monadPlus(Monoid<ObservableKind<T>> m){
+        public static <T> MonadPlus<observable> monadPlusK(Monoid<ObservableKind<T>> m){
+            Monoid<Higher<observable,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<observable> monadPlus(Monoid<Higher<observable,T>> m){
             Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -835,11 +926,11 @@ public static <T> MonadPlus<observable> monadPlus(Monoid<ObservableKind<T>> m){
         public static <C2,T> Traverse<observable> traverse(){
             BiFunction<Applicative<C2>,ObservableKind<Higher<C2, T>>,Higher<C2, ObservableKind<T>>> sequenceFn = (ap, observable) -> {
 
-                Higher<C2,ObservableKind<T>> identity = ap.unit(ObservableKind.widen(Observable.empty()));
+                Higher<C2,ObservableKind<T>> identity = ap.unit(widen(Observable.empty()));
 
-                BiFunction<Higher<C2,ObservableKind<T>>,Higher<C2,T>,Higher<C2,ObservableKind<T>>> combineToObservable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> ObservableKind.widen(Observable.concat(ObservableKind.narrow(a),Observable.just(b)))),acc,next);
+                BiFunction<Higher<C2,ObservableKind<T>>,Higher<C2,T>,Higher<C2,ObservableKind<T>>> combineToObservable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(Observable.concat(ObservableKind.narrow(a),Observable.just(b)))),acc,next);
 
-                BinaryOperator<Higher<C2,ObservableKind<T>>> combineObservables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return ObservableKind.widen(Observable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
+                BinaryOperator<Higher<C2,ObservableKind<T>>> combineObservables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return widen(Observable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
 
                 return ReactiveSeq.fromPublisher(observable).reduce(identity,
                         combineToObservable,
@@ -874,26 +965,157 @@ public static <T> Foldable<observable> foldable(){
         }
 
         private static  <T> ObservableKind<T> concat(ObservableKind<T> l1, ObservableKind<T> l2){
-            return ObservableKind.widen(Observable.concat(l1.narrow(),l2.narrow()));
+            return widen(Observable.concat(l1.narrow(),l2.narrow()));
         }
         private <T> ObservableKind<T> of(T value){
-            return ObservableKind.widen(Observable.just(value));
+            return widen(Observable.just(value));
         }
         private static <T,R> ObservableKind<R> ap(ObservableKind<Function< T, R>> lt, ObservableKind<T> observable){
-            return ObservableKind.widen(lt.zipWith(observable.narrow(),(a, b)->a.apply(b)));
+            return widen(lt.zipWith(observable.narrow(),(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<observable,R> flatMap(Higher<observable,T> lt, Function<? super T, ? extends  Higher<observable,R>> fn){
             Func1<? super T, ? extends  Observable<R>> f = t->fn.andThen(ObservableKind::narrow).apply(t);
 
-            return ObservableKind.widen(ObservableKind.narrowK(lt)
+            return widen(ObservableKind.narrowK(lt)
                     .flatMap(f));
         }
         private static <T,R> ObservableKind<R> map(ObservableKind<T> lt, Function<? super T, ? extends R> fn){
-            return ObservableKind.widen(lt.map(in->fn.apply(in)));
+            return widen(lt.map(in->fn.apply(in)));
         }
         private static <T> ObservableKind<T> filter(Higher<observable,T> lt, Predicate<? super T> fn){
-            return ObservableKind.widen(ObservableKind.narrow(lt).filter(in->fn.test(in)));
+            return widen(ObservableKind.narrow(lt).filter(in->fn.test(in)));
+        }
+        public static Unfoldable<observable> unfoldable(){
+            return new Unfoldable<observable>() {
+                @Override
+                public <R, T> Higher<observable, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return widen(Observables.fromStream(ReactiveSeq.unfold(b,fn)));
+                }
+            };
         }
     }
 
+    public static interface ObservableNested {
+
+        public static <T> Nested<observable,observable,T> observable(Observable<Observable<T>> nested){
+            Observable<ObservableKind<T>> f = nested.map(ObservableKind::widen);
+            ObservableKind<ObservableKind<T>> x = widen(f);
+            ObservableKind<Higher<observable,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(), Observables.Instances.definitions());
+        }
+
+        public static <T> Nested<observable,reactiveSeq,T> reactiveSeq(Observable<ReactiveSeq<T>> nested){
+            ObservableKind<ReactiveSeq<T>> x = widen(nested);
+            ObservableKind<Higher<reactiveSeq,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<observable,maybe,T> maybe(Observable<Maybe<T>> nested){
+            ObservableKind<Maybe<T>> x = widen(nested);
+            ObservableKind<Higher<maybe,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<observable,eval,T> eval(Observable<Eval<T>> nested){
+            ObservableKind<Eval<T>> x = widen(nested);
+            ObservableKind<Higher<eval,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<observable,future,T> future(Observable<cyclops.async.Future<T>> nested){
+            ObservableKind<cyclops.async.Future<T>> x = widen(nested);
+            ObservableKind<Higher<future,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<observable,Higher<xor,S>, P> xor(Observable<Xor<S, P>> nested){
+            ObservableKind<Xor<S, P>> x = widen(nested);
+            ObservableKind<Higher<Higher<xor,S>, P>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<observable,Higher<reader,S>, T> reader(Observable<Reader<S, T>> nested){
+            ObservableKind<Reader<S, T>> x = widen(nested);
+            ObservableKind<Higher<Higher<reader,S>, T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<observable,Higher<Witness.tryType,S>, P> cyclopsTry(Observable<cyclops.control.Try<P, S>> nested){
+            ObservableKind<cyclops.control.Try<P, S>> x = widen(nested);
+            ObservableKind<Higher<Higher<Witness.tryType,S>, P>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<observable,optional,T> javaOptional(Observable<Optional<T>> nested){
+            Observable<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            ObservableKind<OptionalKind<T>> x = ObservableKind.widen(f);
+
+            ObservableKind<Higher<optional,T>> y = (ObservableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<observable,completableFuture,T> javaCompletableFuture(Observable<CompletableFuture<T>> nested){
+            Observable<CompletableFutureKind<T>> f = nested.map(o -> CompletableFutureKind.widen(o));
+            ObservableKind<CompletableFutureKind<T>> x = ObservableKind.widen(f);
+            ObservableKind<Higher<completableFuture,T>> y = (ObservableKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<observable,Witness.stream,T> javaStream(Observable<java.util.stream.Stream<T>> nested){
+            Observable<StreamKind<T>> f = nested.map(o -> StreamKind.widen(o));
+            ObservableKind<StreamKind<T>> x = ObservableKind.widen(f);
+            ObservableKind<Higher<Witness.stream,T>> y = (ObservableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedObservable{
+        public static <T> Nested<reactiveSeq,observable,T> reactiveSeq(ReactiveSeq<Observable<T>> nested){
+            ReactiveSeq<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,observable,T> maybe(Maybe<Observable<T>> nested){
+            Maybe<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,observable,T> eval(Eval<Observable<T>> nested){
+            Eval<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<future,observable,T> future(cyclops.async.Future<Observable<T>> nested){
+            cyclops.async.Future<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,observable, P> xor(Xor<S, Observable<P>> nested){
+            Xor<S, Higher<observable,P>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,observable, T> reader(Reader<S, Observable<T>> nested){
+
+            Reader<S, Higher<observable, T>>  x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,observable, P> cyclopsTry(cyclops.control.Try<Observable<P>, S> nested){
+            cyclops.control.Try<Higher<observable,P>, S> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,observable,T> javaOptional(Optional<Observable<T>> nested){
+            Optional<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,observable,T> javaCompletableFuture(CompletableFuture<Observable<T>> nested){
+            CompletableFuture<Higher<observable,T>> x = nested.thenApply(ObservableKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,observable,T> javaStream(java.util.stream.Stream<Observable<T>> nested){
+            java.util.stream.Stream<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
+
+
+
 }

From 26a3b66f78873a13af8838d173413d65a6372645 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 14:56:27 +0100
Subject: [PATCH 17/30] Rx2 migration

---
 .../com/aol/cyclops/rx2/hkt/FlowableKind.java |  28 ++
 .../com/aol/cyclops/rx2/hkt/MaybeKind.java    |  25 ++
 .../aol/cyclops/rx2/hkt/ObservableKind.java   |  25 ++
 .../com/aol/cyclops/rx2/hkt/SingleKind.java   |  34 ++-
 .../java/cyclops/companion/rx2/Flowables.java | 277 ++++++++++++++++--
 .../java/cyclops/companion/rx2/Maybes.java    |  92 +++++-
 .../cyclops/companion/rx2/Observables.java    | 267 ++++++++++++++++-
 .../java/cyclops/companion/rx2/Singles.java   | 237 ++++++++++++++-
 8 files changed, 934 insertions(+), 51 deletions(-)

diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java
index 64b5e0f0..ad971725 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/FlowableKind.java
@@ -2,9 +2,16 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.rx2.Flowables;
+import cyclops.companion.rx2.Observables;
 import cyclops.monads.Rx2Witness;
 import cyclops.monads.Rx2Witness.flowable;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.reactivex.*;
 import io.reactivex.Observable;
 import io.reactivex.annotations.*;
@@ -56,6 +63,27 @@ private FlowableKind(Flowable<T> boxed) {
         this.boxed = boxed;
     }
 
+
+    public <R> FlowableKind<R> fold(java.util.function.Function<? super Flowable<?  super T>,? extends Flowable<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<flowable,T> allTypeclasses(){
+        return Active.of(this, Flowables.Instances.definitions());
+    }
+
+    public static <T> Higher<flowable,T> widenK(final Flowable<T> completableList) {
+
+        return new FlowableKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<flowable,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Flowables.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> StreamT<W, T> liftM(W witness) {
+        return Flowables.reactiveSeq(boxed).liftM(witness);
+    }
+
     @Override
     public void subscribe(Subscriber<? super T> s) {
         boxed.subscribe(s);
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java
index 1675c859..0b5a1b89 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/MaybeKind.java
@@ -3,9 +3,16 @@
 
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.async.Future;
+import cyclops.companion.rx2.Flowables;
 import cyclops.companion.rx2.Maybes;
 import cyclops.monads.Rx2Witness;
 import cyclops.monads.Rx2Witness.maybe;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.StreamT;
+import cyclops.monads.transformers.rx2.MaybeT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.reactivex.*;
 import io.reactivex.annotations.*;
 import io.reactivex.disposables.Disposable;
@@ -33,7 +40,25 @@ private MaybeKind(Maybe<T> boxed) {
         this.boxed = boxed;
     }
 
+    public <R> MaybeKind<R> fold(java.util.function.Function<? super Maybe<?  super T>,? extends Maybe<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<maybe,T> allTypeclasses(){
+        return Active.of(this, Maybes.Instances.definitions());
+    }
 
+    public static <T> Higher<maybe,T> widenK(final Maybe<T> completableList) {
+
+        return new MaybeKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<maybe,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Maybes.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> MaybeT<W, T> liftM(W witness) {
+        return MaybeT.of(witness.adapter().unit(boxed));
+    }
     
     /**
      * Construct a HKT encoded completed Maybe
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java
index aa89f6c9..ff37939f 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/ObservableKind.java
@@ -11,6 +11,11 @@
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.monads.Rx2Witness;
 import cyclops.monads.Rx2Witness.observable;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.StreamT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.reactivex.*;
 import io.reactivex.annotations.*;
 import io.reactivex.disposables.Disposable;
@@ -41,6 +46,26 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final class ObservableKind<T> implements Higher<observable, T>, Publisher<T> {
 
+    public <R> ObservableKind<R> fold(java.util.function.Function<? super Observable<?  super T>,? extends Observable<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<observable,T> allTypeclasses(){
+        return Active.of(this, Observables.Instances.definitions());
+    }
+
+    public static <T> Higher<observable,T> widenK(final Observable<T> completableList) {
+
+        return new ObservableKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<observable,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Observables.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> StreamT<W, T> liftM(W witness) {
+        return Observables.reactiveSeq(boxed).liftM(witness);
+    }
+
     /**
      * Construct a HKT encoded completed Observable
      * 
diff --git a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java
index a7c21dba..b82f4f57 100644
--- a/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java
+++ b/cyclops-rxjava2/src/main/java/com/aol/cyclops/rx2/hkt/SingleKind.java
@@ -3,8 +3,16 @@
 
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.async.Future;
+import cyclops.companion.rx2.Maybes;
+import cyclops.companion.rx2.Singles;
 import cyclops.monads.Rx2Witness;
 import cyclops.monads.Rx2Witness.single;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.rx2.MaybeT;
+import cyclops.monads.transformers.rx2.SingleT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import io.reactivex.*;
 import io.reactivex.annotations.*;
 import io.reactivex.disposables.Disposable;
@@ -44,15 +52,25 @@ private SingleKind(Single<T> boxed) {
         this.boxed = boxed;
     }
 
-    /**
-     * Witness type
-     * 
-     * @author johnmcclean
-     *
-     */
-    public static class µ {
+    public <R> SingleKind<R> fold(java.util.function.Function<? super Single<?  super T>,? extends Single<R>> op){
+        return widen(op.apply(boxed));
+    }
+    public Active<single,T> allTypeclasses(){
+        return Active.of(this, Singles.Instances.definitions());
+    }
+
+    public static <T> Higher<single,T> widenK(final Single<T> completableList) {
+
+        return new SingleKind<>(
+                completableList);
+    }
+    public <W2,R> Nested<single,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Singles.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> SingleT<W, T> liftM(W witness) {
+        return SingleT.of(witness.adapter().unit(boxed));
     }
-    
     /**
      * Construct a HKT encoded completed Single
      * 
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java
index 917af553..8887fa0c 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Flowables.java
@@ -2,8 +2,17 @@
 
 import com.aol.cyclops.rx2.adapter.FlowableReactiveSeq;
 import com.aol.cyclops.rx2.hkt.FlowableKind;
+import com.aol.cyclops.rx2.hkt.MaybeKind;
+import com.aol.cyclops.rx2.hkt.ObservableKind;
+import com.aol.cyclops.rx2.hkt.SingleKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.companion.Streams;
+import cyclops.control.Eval;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
@@ -11,25 +20,41 @@
 
 import cyclops.monads.Rx2Witness;
 import cyclops.monads.Rx2Witness.flowable;
+import cyclops.monads.Rx2Witness.maybe;
+import cyclops.monads.Rx2Witness.observable;
+import cyclops.monads.Rx2Witness.single;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.eval;
+import cyclops.monads.Witness.reactiveSeq;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
-import io.reactivex.BackpressureStrategy;
-import io.reactivex.Flowable;
+import io.reactivex.*;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 import org.reactivestreams.Publisher;
 
 import java.time.Duration;
-import java.util.Observable;
+
+import java.util.Optional;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.*;
 import java.util.stream.Stream;
 
+import static com.aol.cyclops.rx2.hkt.FlowableKind.widen;
+
+
 /**
  * Companion class for working with Reactor Flowable types
  * 
@@ -461,16 +486,82 @@ public static <T, R1, R> Flowable<R> forEach(Flowable<? extends T> value1,
         });
 
     }
-
+    public static <T> Active<flowable,T> allTypeclasses(Flowable<T> type){
+        return Active.of(FlowableKind.widen(type), Flowables.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<flowable,W2,R> mapM(Flowable<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Flowable<Higher<W2, R>> e = type.map(x->fn.apply(x));
+        FlowableKind<Higher<W2, R>> lk = FlowableKind.widen(e);
+        return Nested.of(lk, Flowables.Instances.definitions(), defs);
+    }
 
     /**
      * Companion class for creating Type Class instances for working with Flowables
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
+        public static InstanceDefinitions<flowable> definitions() {
+            return new InstanceDefinitions<flowable>() {
+
+
+                @Override
+                public <T, R> Functor<flowable> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<flowable> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<flowable> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<flowable> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> cyclops.control.Maybe<MonadZero<flowable>> monadZero() {
+                    return cyclops.control.Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<flowable>> monadPlus() {
+                    return cyclops.control.Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<flowable>> monadPlus(Monoid<Higher<flowable, T>> m) {
+                    return cyclops.control.Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> cyclops.control.Maybe<Traverse<flowable>> traverse() {
+                    return cyclops.control.Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Foldable<flowable>> foldable() {
+                    return cyclops.control.Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Comonad<flowable>> comonad() {
+                    return cyclops.control.Maybe.none();
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Unfoldable<flowable>> unfoldable() {
+                    return cyclops.control.Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
 
         /**
          *
@@ -613,7 +704,7 @@ public static <T,R> Monad<flowable> monad(){
          */
         public static <T,R> MonadZero<flowable> monadZero(){
             BiFunction<Higher<flowable,T>,Predicate<? super T>,Higher<flowable,T>> filter = Instances::filter;
-            Supplier<Higher<flowable, T>> zero = ()-> FlowableKind.widen(Flowable.empty());
+            Supplier<Higher<flowable, T>> zero = ()-> widen(Flowable.empty());
             return General.<flowable,T,R>monadZero(monad(), zero,filter);
         }
         /**
@@ -629,7 +720,7 @@ public static <T,R> MonadZero<flowable> monadZero(){
          * @return Type class for combining Flowables by concatenation
          */
         public static <T> MonadPlus<flowable> monadPlus(){
-            Monoid<FlowableKind<T>> m = Monoid.of(FlowableKind.widen(Flowable.<T>empty()), Instances::concat);
+            Monoid<FlowableKind<T>> m = Monoid.of(widen(Flowable.<T>empty()), Instances::concat);
             Monoid<Higher<flowable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -649,7 +740,11 @@ public static <T> MonadPlus<flowable> monadPlus(){
          * @param m Monoid to use for combining Flowables
          * @return Type class for combining Flowables
          */
-        public static <T> MonadPlus<flowable> monadPlus(Monoid<FlowableKind<T>> m){
+        public static <T> MonadPlus<flowable> monadPlusK(Monoid<FlowableKind<T>> m){
+            Monoid<Higher<flowable,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<flowable> monadPlus(Monoid<Higher<flowable,T>> m){
             Monoid<Higher<flowable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -660,11 +755,11 @@ public static <T> MonadPlus<flowable> monadPlus(Monoid<FlowableKind<T>> m){
         public static <C2,T> Traverse<flowable> traverse(){
             BiFunction<Applicative<C2>,FlowableKind<Higher<C2, T>>,Higher<C2, FlowableKind<T>>> sequenceFn = (ap, flowable) -> {
 
-                Higher<C2,FlowableKind<T>> identity = ap.unit(FlowableKind.widen(Flowable.empty()));
+                Higher<C2,FlowableKind<T>> identity = ap.unit(widen(Flowable.empty()));
 
-                BiFunction<Higher<C2,FlowableKind<T>>,Higher<C2,T>,Higher<C2,FlowableKind<T>>> combineToFlowable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> FlowableKind.widen(Flowable.concat(a,Flowable.just(b)))),acc,next);
+                BiFunction<Higher<C2,FlowableKind<T>>,Higher<C2,T>,Higher<C2,FlowableKind<T>>> combineToFlowable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(Flowable.concat(a,Flowable.just(b)))),acc,next);
 
-                BinaryOperator<Higher<C2,FlowableKind<T>>> combineFlowables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return FlowableKind.widen(Flowable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
+                BinaryOperator<Higher<C2,FlowableKind<T>>> combineFlowables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return widen(Flowable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
 
                 return ReactiveSeq.fromPublisher(flowable).reduce(identity,
                         combineToFlowable,
@@ -699,22 +794,170 @@ public static <T> Foldable<flowable> foldable(){
         }
 
         private static  <T> FlowableKind<T> concat(FlowableKind<T> l1, FlowableKind<T> l2){
-            return FlowableKind.widen(Flowable.concat(l1,l2));
+            return widen(Flowable.concat(l1,l2));
         }
         private static <T> FlowableKind<T> of(T value){
-            return FlowableKind.widen(Flowable.just(value));
+            return widen(Flowable.just(value));
         }
         private static <T,R> FlowableKind<R> ap(FlowableKind<Function< T, R>> lt, FlowableKind<T> flowable){
-            return FlowableKind.widen(lt.zipWith(flowable,(a, b)->a.apply(b)));
+            return widen(lt.zipWith(flowable,(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<flowable,R> flatMap(Higher<flowable,T> lt, Function<? super T, ? extends  Higher<flowable,R>> fn){
-            return FlowableKind.widen(FlowableKind.narrowK(lt).flatMap(Functions.rxFunction(fn.andThen(FlowableKind::narrowK))));
+            return widen(FlowableKind.narrowK(lt).flatMap(Functions.rxFunction(fn.andThen(FlowableKind::narrowK))));
         }
         private static <T,R> FlowableKind<R> map(FlowableKind<T> lt, Function<? super T, ? extends R> fn){
-            return FlowableKind.widen(lt.map(Functions.rxFunction(fn)));
+            return widen(lt.map(Functions.rxFunction(fn)));
         }
         private static <T> FlowableKind<T> filter(Higher<flowable,T> lt, Predicate<? super T> fn){
-            return FlowableKind.widen(FlowableKind.narrow(lt).filter(Functions.rxPredicate(fn)));
+            return widen(FlowableKind.narrow(lt).filter(Functions.rxPredicate(fn)));
+        }
+        public static Unfoldable<flowable> unfoldable() {
+            return new Unfoldable<flowable>() {
+
+                @Override
+                public <R, T> Higher<flowable, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return widen(Flowables.fromStream(ReactiveSeq.unfold(b, fn)));
+                }
+            };
+        }
+    }
+
+    public static interface FlowableNested {
+
+        public static <T> Nested<flowable,flowable,T> flowable(Flowable<Flowable<T>> nested){
+            Flowable<FlowableKind<T>> f = nested.map(FlowableKind::widen);
+            FlowableKind<FlowableKind<T>> x = widen(f);
+            FlowableKind<Higher<flowable,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(), Flowables.Instances.definitions());
+        }
+        public static <T> Nested<flowable,observable,T> observable(Flowable<Observable<T>> nested){
+            Flowable<ObservableKind<T>> f = nested.map(ObservableKind::widen);
+            FlowableKind<ObservableKind<T>> x = widen(f);
+            FlowableKind<Higher<observable,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(), Observables.Instances.definitions());
+        }
+
+        public static <T> Nested<flowable,maybe,T> maybe(Flowable<Maybe<T>> nested){
+            Flowable<MaybeKind<T>> f = nested.map(MaybeKind::widen);
+            FlowableKind<MaybeKind<T>> x = widen(f);
+            FlowableKind<Higher<maybe,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(), Maybes.Instances.definitions());
+        }
+        public static <T> Nested<flowable,single,T> single(Flowable<Single<T>> nested){
+            Flowable<SingleKind<T>> f = nested.map(SingleKind::widen);
+            FlowableKind<SingleKind<T>> x = widen(f);
+            FlowableKind<Higher<single,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(), Singles.Instances.definitions());
+        }
+        public static <T> Nested<flowable,reactiveSeq,T> reactiveSeq(Flowable<ReactiveSeq<T>> nested){
+            FlowableKind<ReactiveSeq<T>> x = widen(nested);
+            FlowableKind<Higher<reactiveSeq,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<flowable,Witness.maybe,T> cyclopsMaybe(Flowable<cyclops.control.Maybe<T>> nested){
+            FlowableKind<cyclops.control.Maybe<T>> x = widen(nested);
+            FlowableKind<Higher<Witness.maybe,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.control.Maybe.Instances.definitions());
+        }
+        public static <T> Nested<flowable,eval,T> eval(Flowable<Eval<T>> nested){
+            FlowableKind<Eval<T>> x = widen(nested);
+            FlowableKind<Higher<eval,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<flowable,Witness.future,T> future(Flowable<cyclops.async.Future<T>> nested){
+            FlowableKind<cyclops.async.Future<T>> x = widen(nested);
+            FlowableKind<Higher<Witness.future,T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<flowable,Higher<Witness.xor,S>, P> xor(Flowable<Xor<S, P>> nested){
+            FlowableKind<Xor<S, P>> x = widen(nested);
+            FlowableKind<Higher<Higher<Witness.xor,S>, P>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<flowable,Higher<Witness.reader,S>, T> reader(Flowable<Reader<S, T>> nested){
+            FlowableKind<Reader<S, T>> x = widen(nested);
+            FlowableKind<Higher<Higher<Witness.reader,S>, T>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<flowable,Higher<Witness.tryType,S>, P> cyclopsTry(Flowable<cyclops.control.Try<P, S>> nested){
+            FlowableKind<cyclops.control.Try<P, S>> x = widen(nested);
+            FlowableKind<Higher<Higher<Witness.tryType,S>, P>> y = (FlowableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<flowable,Witness.optional,T> javaOptional(Flowable<Optional<T>> nested){
+            Flowable<Optionals.OptionalKind<T>> f = nested.map(o -> Optionals.OptionalKind.widen(o));
+            FlowableKind<Optionals.OptionalKind<T>> x = FlowableKind.widen(f);
+
+            FlowableKind<Higher<Witness.optional,T>> y = (FlowableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<flowable,Witness.completableFuture,T> javaCompletableFuture(Flowable<CompletableFuture<T>> nested){
+            Flowable<CompletableFutures.CompletableFutureKind<T>> f = nested.map(o -> CompletableFutures.CompletableFutureKind.widen(o));
+            FlowableKind<CompletableFutures.CompletableFutureKind<T>> x = FlowableKind.widen(f);
+            FlowableKind<Higher<Witness.completableFuture,T>> y = (FlowableKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<flowable,Witness.stream,T> javaStream(Flowable<java.util.stream.Stream<T>> nested){
+            Flowable<Streams.StreamKind<T>> f = nested.map(o -> Streams.StreamKind.widen(o));
+            FlowableKind<Streams.StreamKind<T>> x = FlowableKind.widen(f);
+            FlowableKind<Higher<Witness.stream,T>> y = (FlowableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedFlowable{
+        public static <T> Nested<reactiveSeq,flowable,T> reactiveSeq(ReactiveSeq<Flowable<T>> nested){
+            ReactiveSeq<Higher<flowable,T>> x = nested.map(FlowableKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<Witness.maybe,flowable,T> maybe(cyclops.control.Maybe<Flowable<T>> nested){
+            cyclops.control.Maybe<Higher<flowable,T>> x = nested.map(FlowableKind::widenK);
+
+            return Nested.of(x, cyclops.control.Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,flowable,T> eval(Eval<Flowable<T>> nested){
+            Eval<Higher<flowable,T>> x = nested.map(FlowableKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,flowable,T> future(cyclops.async.Future<Flowable<T>> nested){
+            cyclops.async.Future<Higher<flowable,T>> x = nested.map(FlowableKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<Witness.xor,S>,flowable, P> xor(Xor<S, Flowable<P>> nested){
+            Xor<S, Higher<flowable,P>> x = nested.map(FlowableKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<Witness.reader,S>,flowable, T> reader(Reader<S, Flowable<T>> nested){
+
+            Reader<S, Higher<flowable, T>>  x = nested.map(FlowableKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,flowable, P> cyclopsTry(cyclops.control.Try<Flowable<P>, S> nested){
+            cyclops.control.Try<Higher<flowable,P>, S> x = nested.map(FlowableKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.optional,flowable,T> javaOptional(Optional<Flowable<T>> nested){
+            Optional<Higher<flowable,T>> x = nested.map(FlowableKind::widenK);
+
+            return  Nested.of(Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<Witness.completableFuture,flowable,T> javaCompletableFuture(CompletableFuture<Flowable<T>> nested){
+            CompletableFuture<Higher<flowable,T>> x = nested.thenApply(FlowableKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,flowable,T> javaStream(java.util.stream.Stream<Flowable<T>> nested){
+            java.util.stream.Stream<Higher<flowable,T>> x = nested.map(FlowableKind::widenK);
+
+            return Nested.of(Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
         }
     }
 
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
index 495d10ed..83aab2c1 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
@@ -1,6 +1,7 @@
 package cyclops.companion.rx2;
 
 
+import com.aol.cyclops.rx2.hkt.FlowableKind;
 import com.aol.cyclops.rx2.hkt.MaybeKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.react.Status;
@@ -20,9 +21,13 @@
 import cyclops.monads.Rx2Witness.maybe;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.rx2.MaybeT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
@@ -40,6 +45,8 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import static com.aol.cyclops.rx2.hkt.MaybeKind.widen;
+
 /**
  * Companion class for working with Reactor Maybe types
  * 
@@ -454,15 +461,80 @@ public static <R> Maybe<R> narrow(Maybe<? extends R> apply) {
         return (Maybe<R>)apply;
     }
 
+    public static <T> Active<maybe,T> allTypeclasses(Maybe<T> type){
+        return Active.of(widen(type), Maybes.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<maybe,W2,R> mapM(Maybe<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Maybe<Higher<W2, R>> e = type.map(x->fn.apply(x));
+        MaybeKind<Higher<W2, R>> lk = MaybeKind.widen(e);
+        return Nested.of(lk, Maybes.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Maybes
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<maybe> definitions() {
+            return new InstanceDefinitions<maybe>() {
+
+                @Override
+                public <T, R> Functor<maybe> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<maybe> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<maybe> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<maybe> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> cyclops.control.Maybe<MonadZero<maybe>> monadZero() {
+                    return cyclops.control.Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<maybe>> monadPlus() {
+                    return cyclops.control.Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<maybe>> monadPlus(Monoid<Higher<maybe, T>> m) {
+                    return cyclops.control.Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> cyclops.control.Maybe<Traverse<maybe>> traverse() {
+                    return cyclops.control.Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Foldable<maybe>> foldable() {
+                    return cyclops.control.Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Comonad<maybe>> comonad() {
+                    return cyclops.control.Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Unfoldable<maybe>> unfoldable() {
+                    return cyclops.control.Maybe.none();
+                }
+            };
+        }
         /**
          *
          * Transform a Maybe, mulitplying every element by 2
@@ -624,7 +696,7 @@ public static <T> MonadPlus<maybe> monadPlus(){
 
 
             Monoid<MaybeKind<T>> m = Monoid.of(MaybeKind.<T>widen(Maybe.empty()),
-                    (f,g)-> MaybeKind.widen(Maybe.ambArray(f.narrow(),g.narrow())));
+                    (f,g)-> widen(Maybe.ambArray(f.narrow(),g.narrow())));
 
             Monoid<Higher<maybe,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
@@ -645,7 +717,11 @@ public static <T> MonadPlus<maybe> monadPlus(){
          * @param m Monoid to use for combining Maybes
          * @return Type class for combining Maybes
          */
-        public static <T> MonadPlus<maybe> monadPlus(Monoid<MaybeKind<T>> m){
+        public static <T> MonadPlus<maybe> monadPlusK(Monoid<MaybeKind<T>> m){
+            Monoid<Higher<maybe,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<maybe> monadPlus(Monoid<Higher<maybe,T>> m){
             Monoid<Higher<maybe,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -684,19 +760,19 @@ public static <T> Comonad<maybe> comonad(){
         }
 
         private static <T> MaybeKind<T> of(T value){
-            return MaybeKind.widen(Maybe.just(value));
+            return widen(Maybe.just(value));
         }
         private static <T,R> MaybeKind<R> ap(MaybeKind<Function< T, R>> lt, MaybeKind<T> list){
 
 
-            return MaybeKind.widen(Maybes.combine(lt.narrow(),list.narrow(), (a, b)->a.apply(b)));
+            return widen(Maybes.combine(lt.narrow(),list.narrow(), (a, b)->a.apply(b)));
 
         }
         private static <T,R> Higher<maybe,R> flatMap(Higher<maybe,T> lt, Function<? super T, ? extends  Higher<maybe,R>> fn){
-            return MaybeKind.widen(MaybeKind.narrow(lt).flatMap(Functions.rxFunction(fn.andThen(MaybeKind::narrow))));
+            return widen(MaybeKind.narrow(lt).flatMap(Functions.rxFunction(fn.andThen(MaybeKind::narrow))));
         }
         private static <T,R> MaybeKind<R> map(MaybeKind<T> lt, Function<? super T, ? extends R> fn){
-            return MaybeKind.widen(lt.narrow().map(Functions.rxFunction(fn)));
+            return widen(lt.narrow().map(Functions.rxFunction(fn)));
         }
 
 
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java
index 93192ac9..2637feb5 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Observables.java
@@ -1,12 +1,22 @@
 package cyclops.companion.rx2;
 
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.function.*;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
 import com.aol.cyclops.rx2.adapter.ObservableReactiveSeq;
+import com.aol.cyclops.rx2.hkt.FlowableKind;
+import com.aol.cyclops.rx2.hkt.MaybeKind;
+import com.aol.cyclops.rx2.hkt.SingleKind;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.companion.Streams;
+import cyclops.control.*;
 import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.flowable;
 import cyclops.monads.Rx2Witness.observable;
 import com.aol.cyclops.rx2.hkt.ObservableKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -15,22 +25,33 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.Rx2Witness.single;
+import cyclops.monads.Witness;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.StreamT;
 import cyclops.stream.ReactiveSeq;
 
 
 import cyclops.stream.Spouts;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
 import io.reactivex.*;
+import io.reactivex.Maybe;
 import io.reactivex.schedulers.Schedulers;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 import org.reactivestreams.Publisher;
 
+import static com.aol.cyclops.rx2.hkt.ObservableKind.widen;
+
 
 /**
  * Companion class for working with RxJava Observable types
@@ -579,15 +600,80 @@ public static <T, R1, R> Observable<R> forEach(Observable<? extends T> value1,
         });
 
     }
-
+    public static <T> Active<observable,T> allTypeclasses(Observable<T> type){
+        return Active.of(widen(type), Observables.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<observable,W2,R> mapM(Observable<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Observable<Higher<W2, R>> e = type.map(x->fn.apply(x));
+        ObservableKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, Observables.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Observables
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
-
+        public static InstanceDefinitions<observable> definitions() {
+            return new InstanceDefinitions<observable>() {
+
+
+                @Override
+                public <T, R> Functor<observable> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<observable> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<observable> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<observable> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> cyclops.control.Maybe<MonadZero<observable>> monadZero() {
+                    return cyclops.control.Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<observable>> monadPlus() {
+                    return cyclops.control.Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<observable>> monadPlus(Monoid<Higher<observable, T>> m) {
+                    return cyclops.control.Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> cyclops.control.Maybe<Traverse<observable>> traverse() {
+                    return cyclops.control.Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Foldable<observable>> foldable() {
+                    return cyclops.control.Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Comonad<observable>> comonad() {
+                    return cyclops.control.Maybe.none();
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Unfoldable<observable>> unfoldable() {
+                    return cyclops.control.Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
 
         /**
          *
@@ -729,7 +815,7 @@ public static <T,R> Monad<observable> monad(){
          */
         public static <T,R> MonadZero<observable> monadZero(){
             BiFunction<Higher<observable,T>,Predicate<? super T>,Higher<observable,T>> filter = Instances::filter;
-            Supplier<Higher<observable, T>> zero = ()-> ObservableKind.widen(Observable.empty());
+            Supplier<Higher<observable, T>> zero = ()-> widen(Observable.empty());
             return General.<observable,T,R>monadZero(monad(), zero,filter);
         }
         /**
@@ -745,7 +831,7 @@ public static <T,R> MonadZero<observable> monadZero(){
          * @return Type class for combining Observables by concatenation
          */
         public static <T> MonadPlus<observable> monadPlus(){
-            Monoid<ObservableKind<T>> m = Monoid.of(ObservableKind.widen(Observable.<T>empty()), Instances::concat);
+            Monoid<ObservableKind<T>> m = Monoid.of(widen(Observable.<T>empty()), Instances::concat);
             Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -765,7 +851,11 @@ public static <T> MonadPlus<observable> monadPlus(){
          * @param m Monoid to use for combining Observables
          * @return Type class for combining Observables
          */
-        public static <T> MonadPlus<observable> monadPlus(Monoid<ObservableKind<T>> m){
+        public static <T> MonadPlus<observable> monadPlusK(Monoid<ObservableKind<T>> m){
+            Monoid<Higher<observable,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<observable> monadPlus(Monoid<Higher<observable,T>> m){
             Monoid<Higher<observable,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -776,11 +866,11 @@ public static <T> MonadPlus<observable> monadPlus(Monoid<ObservableKind<T>> m){
         public static <C2,T> Traverse<observable> traverse(){
             BiFunction<Applicative<C2>,ObservableKind<Higher<C2, T>>,Higher<C2, ObservableKind<T>>> sequenceFn = (ap, observable) -> {
 
-                Higher<C2,ObservableKind<T>> identity = ap.unit(ObservableKind.widen(Observable.empty()));
+                Higher<C2,ObservableKind<T>> identity = ap.unit(widen(Observable.empty()));
 
-                BiFunction<Higher<C2,ObservableKind<T>>,Higher<C2,T>,Higher<C2,ObservableKind<T>>> combineToObservable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> ObservableKind.widen(Observable.concat(ObservableKind.narrow(a),Observable.just(b)))),acc,next);
+                BiFunction<Higher<C2,ObservableKind<T>>,Higher<C2,T>,Higher<C2,ObservableKind<T>>> combineToObservable =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> widen(Observable.concat(ObservableKind.narrow(a),Observable.just(b)))),acc,next);
 
-                BinaryOperator<Higher<C2,ObservableKind<T>>> combineObservables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return ObservableKind.widen(Observable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
+                BinaryOperator<Higher<C2,ObservableKind<T>>> combineObservables = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return widen(Observable.concat(l1.narrow(),l2.narrow()));}),a,b); ;
 
                 return ReactiveSeq.fromPublisher(observable).reduce(identity,
                         combineToObservable,
@@ -815,26 +905,173 @@ public static <T> Foldable<observable> foldable(){
         }
 
         private static  <T> ObservableKind<T> concat(ObservableKind<T> l1, ObservableKind<T> l2){
-            return ObservableKind.widen(Observable.concat(l1.narrow(),l2.narrow()));
+            return widen(Observable.concat(l1.narrow(),l2.narrow()));
         }
         private <T> ObservableKind<T> of(T value){
-            return ObservableKind.widen(Observable.just(value));
+            return widen(Observable.just(value));
         }
         private static <T,R> ObservableKind<R> ap(ObservableKind<Function< T, R>> lt, ObservableKind<T> observable){
-            return ObservableKind.widen(lt.zipWith(observable.narrow(),(a, b)->a.apply(b)));
+            return widen(lt.zipWith(observable.narrow(),(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<observable,R> flatMap(Higher<observable,T> lt, Function<? super T, ? extends  Higher<observable,R>> fn){
             io.reactivex.functions.Function<? super T, ? extends  Observable<R>> f = t->fn.andThen(ObservableKind::narrow).apply(t);
 
-            return ObservableKind.widen(ObservableKind.narrowK(lt)
+            return widen(ObservableKind.narrowK(lt)
                     .flatMap(f));
         }
         private static <T,R> ObservableKind<R> map(ObservableKind<T> lt, Function<? super T, ? extends R> fn){
-            return ObservableKind.widen(lt.map(in->fn.apply(in)));
+            return widen(lt.map(in->fn.apply(in)));
         }
         private static <T> ObservableKind<T> filter(Higher<observable,T> lt, Predicate<? super T> fn){
-            return ObservableKind.widen(ObservableKind.narrow(lt).filter(in->fn.test(in)));
+            return widen(ObservableKind.narrow(lt).filter(in->fn.test(in)));
+        }
+        public static Unfoldable<observable> unfoldable() {
+            return new Unfoldable<observable>() {
+                @Override
+                public <R, T> Higher<observable, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    return widen(Observables.fromStream(ReactiveSeq.unfold(b, fn)));
+                }
+
+            };
+        }
+    }
+
+    public static interface ObservableNested {
+
+        public static <T> Nested<observable,observable,T> observable(Observable<Observable<T>> nested){
+            Observable<ObservableKind<T>> f = nested.map(ObservableKind::widen);
+            ObservableKind<ObservableKind<T>> x = widen(f);
+            ObservableKind<Higher<observable,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(), Observables.Instances.definitions());
+        }
+        public static <T> Nested<observable,flowable,T> flowable(Observable<Flowable<T>> nested){
+            Observable<FlowableKind<T>> f = nested.map(FlowableKind::widen);
+            ObservableKind<FlowableKind<T>> x = widen(f);
+            ObservableKind<Higher<flowable,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(), Flowables.Instances.definitions());
+        }
+
+        public static <T> Nested<observable,Rx2Witness.maybe,T> maybe(Observable<Maybe<T>> nested){
+            Observable<MaybeKind<T>> f = nested.map(MaybeKind::widen);
+            ObservableKind<MaybeKind<T>> x = widen(f);
+            ObservableKind<Higher<Rx2Witness.maybe,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(), Maybes.Instances.definitions());
+        }
+        public static <T> Nested<observable,single,T> single(Observable<Single<T>> nested){
+            Observable<SingleKind<T>> f = nested.map(SingleKind::widen);
+            ObservableKind<SingleKind<T>> x = widen(f);
+            ObservableKind<Higher<single,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(), Singles.Instances.definitions());
+        }
+        public static <T> Nested<observable,Witness.reactiveSeq,T> reactiveSeq(Observable<ReactiveSeq<T>> nested){
+            ObservableKind<ReactiveSeq<T>> x = widen(nested);
+            ObservableKind<Higher<Witness.reactiveSeq,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<observable,Witness.maybe,T> cyclopsMaybe(Observable<cyclops.control.Maybe<T>> nested){
+            ObservableKind<cyclops.control.Maybe<T>> x = widen(nested);
+            ObservableKind<Higher<Witness.maybe,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.control.Maybe.Instances.definitions());
+        }
+        public static <T> Nested<observable,Witness.eval,T> eval(Observable<Eval<T>> nested){
+            ObservableKind<Eval<T>> x = widen(nested);
+            ObservableKind<Higher<Witness.eval,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<observable,Witness.future,T> future(Observable<cyclops.async.Future<T>> nested){
+            ObservableKind<cyclops.async.Future<T>> x = widen(nested);
+            ObservableKind<Higher<Witness.future,T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<observable,Higher<Witness.xor,S>, P> xor(Observable<Xor<S, P>> nested){
+            ObservableKind<Xor<S, P>> x = widen(nested);
+            ObservableKind<Higher<Higher<Witness.xor,S>, P>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<observable,Higher<Witness.reader,S>, T> reader(Observable<Reader<S, T>> nested){
+            ObservableKind<Reader<S, T>> x = widen(nested);
+            ObservableKind<Higher<Higher<Witness.reader,S>, T>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
         }
+        public static <S extends Throwable, P> Nested<observable,Higher<Witness.tryType,S>, P> cyclopsTry(Observable<cyclops.control.Try<P, S>> nested){
+            ObservableKind<cyclops.control.Try<P, S>> x = widen(nested);
+            ObservableKind<Higher<Higher<Witness.tryType,S>, P>> y = (ObservableKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<observable,Witness.optional,T> javaOptional(Observable<Optional<T>> nested){
+            Observable<Optionals.OptionalKind<T>> f = nested.map(o -> Optionals.OptionalKind.widen(o));
+            ObservableKind<Optionals.OptionalKind<T>> x = ObservableKind.widen(f);
+
+            ObservableKind<Higher<Witness.optional,T>> y = (ObservableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<observable,Witness.completableFuture,T> javaCompletableFuture(Observable<CompletableFuture<T>> nested){
+            Observable<CompletableFutures.CompletableFutureKind<T>> f = nested.map(o -> CompletableFutures.CompletableFutureKind.widen(o));
+            ObservableKind<CompletableFutures.CompletableFutureKind<T>> x = ObservableKind.widen(f);
+            ObservableKind<Higher<Witness.completableFuture,T>> y = (ObservableKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<observable,Witness.stream,T> javaStream(Observable<java.util.stream.Stream<T>> nested){
+            Observable<Streams.StreamKind<T>> f = nested.map(o -> Streams.StreamKind.widen(o));
+            ObservableKind<Streams.StreamKind<T>> x = ObservableKind.widen(f);
+            ObservableKind<Higher<Witness.stream,T>> y = (ObservableKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
     }
 
+    public static interface NestedObservable{
+        public static <T> Nested<Witness.reactiveSeq,observable,T> reactiveSeq(ReactiveSeq<Observable<T>> nested){
+            ReactiveSeq<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<Witness.maybe,observable,T> maybe(cyclops.control.Maybe<Observable<T>> nested){
+            cyclops.control.Maybe<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x, cyclops.control.Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.eval,observable,T> eval(Eval<Observable<T>> nested){
+            Eval<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,observable,T> future(cyclops.async.Future<Observable<T>> nested){
+            cyclops.async.Future<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<Witness.xor,S>,observable, P> xor(Xor<S, Observable<P>> nested){
+            Xor<S, Higher<observable,P>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<Witness.reader,S>,observable, T> reader(Reader<S, Observable<T>> nested){
+
+            Reader<S, Higher<observable, T>>  x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,observable, P> cyclopsTry(cyclops.control.Try<Observable<P>, S> nested){
+            cyclops.control.Try<Higher<observable,P>, S> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.optional,observable,T> javaOptional(Optional<Observable<T>> nested){
+            Optional<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return  Nested.of(Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<Witness.completableFuture,observable,T> javaCompletableFuture(CompletableFuture<Observable<T>> nested){
+            CompletableFuture<Higher<observable,T>> x = nested.thenApply(ObservableKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,observable,T> javaStream(java.util.stream.Stream<Observable<T>> nested){
+            java.util.stream.Stream<Higher<observable,T>> x = nested.map(ObservableKind::widenK);
+
+            return Nested.of(Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 }
diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java
index 3c18ca3f..82d34ce0 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Singles.java
@@ -1,6 +1,9 @@
 package cyclops.companion.rx2;
 
 
+import com.aol.cyclops.rx2.hkt.FlowableKind;
+import com.aol.cyclops.rx2.hkt.MaybeKind;
+import com.aol.cyclops.rx2.hkt.ObservableKind;
 import com.aol.cyclops.rx2.hkt.SingleKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.react.Status;
@@ -9,8 +12,13 @@
 import com.aol.cyclops2.types.anyM.AnyMValue;
 import cyclops.async.Future;
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.companion.Streams;
 import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.control.lazy.Either;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
@@ -18,16 +26,28 @@
 import cyclops.monads.AnyM;
 
 import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.flowable;
+import cyclops.monads.Rx2Witness.maybe;
+import cyclops.monads.Rx2Witness.observable;
 import cyclops.monads.Rx2Witness.single;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.monads.WitnessType;
 
 import cyclops.monads.transformers.rx2.SingleT;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import io.reactivex.Flowable;
+import io.reactivex.Observable;
 import io.reactivex.Single;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
@@ -35,12 +55,15 @@
 
 
 import java.util.Iterator;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import static com.aol.cyclops.rx2.hkt.SingleKind.widen;
+
 /**
  * Companion class for working with Reactor Single types
  * 
@@ -441,15 +464,81 @@ public static <T> Iterator<T> iterator(Single<T> pub) {
     public static <R> Single<R> narrow(Single<? extends R> apply) {
         return (Single<R>)apply;
     }
-
+    public static <T> Active<single,T> allTypeclasses(Single<T> type){
+        return Active.of(widen(type), Singles.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<single,W2,R> mapM(Single<T> type, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Single<Higher<W2, R>> e = type.map(x->fn.apply(x));
+        SingleKind<Higher<W2, R>> lk = SingleKind.widen(e);
+        return Nested.of(lk, Singles.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Singles
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
+        public static InstanceDefinitions<single> definitions() {
+            return new InstanceDefinitions<single>() {
+
+
+                @Override
+                public <T, R> Functor<single> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<single> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<single> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<single> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> cyclops.control.Maybe<MonadZero<single>> monadZero() {
+                    return cyclops.control.Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<single>> monadPlus() {
+                    return cyclops.control.Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<MonadPlus<single>> monadPlus(Monoid<Higher<single, T>> m) {
+                    return cyclops.control.Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> cyclops.control.Maybe<Traverse<single>> traverse() {
+                    return cyclops.control.Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Foldable<single>> foldable() {
+                    return cyclops.control.Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Comonad<single>> comonad() {
+                    return cyclops.control.Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> cyclops.control.Maybe<Unfoldable<single>> unfoldable() {
+                    return cyclops.control.Maybe.none();
+                }
+            };
+        }
 
         /**
          *
@@ -633,7 +722,11 @@ public static <T> MonadPlus<single> monadPlus(){
          * @param m Monoid to use for combining Singles
          * @return Type class for combining Singles
          */
-        public static <T> MonadPlus<single> monadPlus(Monoid<SingleKind<T>> m){
+        public static <T> MonadPlus<single> monadPlusK(Monoid<SingleKind<T>> m){
+            Monoid<Higher<single,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<single> monadPlus(Monoid<Higher<single,T>> m){
             Monoid<Higher<single,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -695,5 +788,143 @@ private static <C2,T,R> Higher<C2, Higher<single, R>> traverseA(Applicative<C2>
         }
 
     }
+    public static interface SingleNested {
+
+        public static <T> Nested<single,observable,T> observable(Single<Observable<T>> nested){
+            Single<ObservableKind<T>> f = nested.map(ObservableKind::widen);
+            SingleKind<ObservableKind<T>> x = widen(f);
+            SingleKind<Higher<observable,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(), Observables.Instances.definitions());
+        }
+        public static <T> Nested<single,flowable,T> flowable(Single<Flowable<T>> nested){
+            Single<FlowableKind<T>> f = nested.map(FlowableKind::widen);
+            SingleKind<FlowableKind<T>> x = widen(f);
+            SingleKind<Higher<flowable,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(), Flowables.Instances.definitions());
+        }
+
+        public static <T> Nested<single,maybe,T> maybe(Single<Maybe<T>> nested){
+            Single<MaybeKind<T>> f = nested.map(MaybeKind::widen);
+            SingleKind<MaybeKind<T>> x = widen(f);
+            SingleKind<Higher<maybe,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(), Maybes.Instances.definitions());
+        }
+        public static <T> Nested<single,single,T> single(Single<Single<T>> nested){
+            Single<SingleKind<T>> f = nested.map(SingleKind::widen);
+            SingleKind<SingleKind<T>> x = widen(f);
+            SingleKind<Higher<single,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(), Singles.Instances.definitions());
+        }
+        public static <T> Nested<single,reactiveSeq,T> reactiveSeq(Single<ReactiveSeq<T>> nested){
+            SingleKind<ReactiveSeq<T>> x = widen(nested);
+            SingleKind<Higher<reactiveSeq,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<single,Witness.maybe,T> cyclopsMaybe(Single<cyclops.control.Maybe<T>> nested){
+            SingleKind<cyclops.control.Maybe<T>> x = widen(nested);
+            SingleKind<Higher<Witness.maybe,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.control.Maybe.Instances.definitions());
+        }
+        public static <T> Nested<single,eval,T> eval(Single<Eval<T>> nested){
+            SingleKind<Eval<T>> x = widen(nested);
+            SingleKind<Higher<eval,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<single,future,T> future(Single<cyclops.async.Future<T>> nested){
+            SingleKind<cyclops.async.Future<T>> x = widen(nested);
+            SingleKind<Higher<future,T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<single,Higher<xor,S>, P> xor(Single<Xor<S, P>> nested){
+            SingleKind<Xor<S, P>> x = widen(nested);
+            SingleKind<Higher<Higher<xor,S>, P>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<single,Higher<reader,S>, T> reader(Single<Reader<S, T>> nested){
+            SingleKind<Reader<S, T>> x = widen(nested);
+            SingleKind<Higher<Higher<reader,S>, T>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<single,Higher<Witness.tryType,S>, P> cyclopsTry(Single<cyclops.control.Try<P, S>> nested){
+            SingleKind<cyclops.control.Try<P, S>> x = widen(nested);
+            SingleKind<Higher<Higher<Witness.tryType,S>, P>> y = (SingleKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<single,Witness.optional,T> javaOptional(Single<Optional<T>> nested){
+            Single<Optionals.OptionalKind<T>> f = nested.map(o -> Optionals.OptionalKind.widen(o));
+            SingleKind<Optionals.OptionalKind<T>> x = SingleKind.widen(f);
+
+            SingleKind<Higher<Witness.optional,T>> y = (SingleKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<single,Witness.completableFuture,T> javaCompletableFuture(Single<CompletableFuture<T>> nested){
+            Single<CompletableFutures.CompletableFutureKind<T>> f = nested.map(o -> CompletableFutures.CompletableFutureKind.widen(o));
+            SingleKind<CompletableFutures.CompletableFutureKind<T>> x = SingleKind.widen(f);
+            SingleKind<Higher<Witness.completableFuture,T>> y = (SingleKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<single,Witness.stream,T> javaStream(Single<java.util.stream.Stream<T>> nested){
+            Single<Streams.StreamKind<T>> f = nested.map(o -> Streams.StreamKind.widen(o));
+            SingleKind<Streams.StreamKind<T>> x = SingleKind.widen(f);
+            SingleKind<Higher<Witness.stream,T>> y = (SingleKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedSingle{
+        public static <T> Nested<reactiveSeq,single,T> reactiveSeq(ReactiveSeq<Single<T>> nested){
+            ReactiveSeq<Higher<single,T>> x = nested.map(SingleKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<Witness.maybe,single,T> maybe(cyclops.control.Maybe<Single<T>> nested){
+            cyclops.control.Maybe<Higher<single,T>> x = nested.map(SingleKind::widenK);
+
+            return Nested.of(x, cyclops.control.Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,single,T> eval(Eval<Single<T>> nested){
+            Eval<Higher<single,T>> x = nested.map(SingleKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<future,single,T> future(cyclops.async.Future<Single<T>> nested){
+            cyclops.async.Future<Higher<single,T>> x = nested.map(SingleKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,single, P> xor(Xor<S, Single<P>> nested){
+            Xor<S, Higher<single,P>> x = nested.map(SingleKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,single, T> reader(Reader<S, Single<T>> nested){
+
+            Reader<S, Higher<single, T>>  x = nested.map(SingleKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,single, P> cyclopsTry(cyclops.control.Try<Single<P>, S> nested){
+            cyclops.control.Try<Higher<single,P>, S> x = nested.map(SingleKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.optional,single,T> javaOptional(Optional<Single<T>> nested){
+            Optional<Higher<single,T>> x = nested.map(SingleKind::widenK);
+
+            return  Nested.of(Optionals.OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<Witness.completableFuture,single,T> javaCompletableFuture(CompletableFuture<Single<T>> nested){
+            CompletableFuture<Higher<single,T>> x = nested.thenApply(SingleKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,single,T> javaStream(java.util.stream.Stream<Single<T>> nested){
+            java.util.stream.Stream<Higher<single,T>> x = nested.map(SingleKind::widenK);
+
+            return Nested.of(Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 
 }

From e62cd29aab36533f65e964f7bfd6322ced229528 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 14:59:43 +0100
Subject: [PATCH 18/30] add support for maybes

---
 .../java/cyclops/companion/rx2/Maybes.java    | 155 ++++++++++++++++++
 1 file changed, 155 insertions(+)

diff --git a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
index 83aab2c1..02cf37cf 100644
--- a/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
+++ b/cyclops-rxjava2/src/main/java/cyclops/companion/rx2/Maybes.java
@@ -3,6 +3,8 @@
 
 import com.aol.cyclops.rx2.hkt.FlowableKind;
 import com.aol.cyclops.rx2.hkt.MaybeKind;
+import com.aol.cyclops.rx2.hkt.ObservableKind;
+import com.aol.cyclops.rx2.hkt.SingleKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.react.Status;
 import com.aol.cyclops2.types.MonadicValue;
@@ -10,17 +12,30 @@
 import com.aol.cyclops2.types.anyM.AnyMValue;
 import cyclops.async.Future;
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.Optionals;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.companion.Streams;
+import cyclops.companion.Streams.StreamKind;
 import cyclops.control.Eval;
 
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.control.lazy.Either;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.monads.Rx2Witness;
+import cyclops.monads.Rx2Witness.flowable;
 import cyclops.monads.Rx2Witness.maybe;
+import cyclops.monads.Rx2Witness.observable;
+import cyclops.monads.Rx2Witness.single;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.rx2.MaybeT;
+import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
@@ -34,11 +49,13 @@
 
 import io.reactivex.Flowable;
 import io.reactivex.Maybe;
+import io.reactivex.Observable;
 import io.reactivex.Single;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
 import java.util.Iterator;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -783,5 +800,143 @@ private static <C2,T,R> Higher<C2, Higher<maybe, R>> traverseA(Applicative<C2> a
         }
 
     }
+    public static interface MaybeNested {
+
+        public static <T> Nested<maybe,observable,T> observable(Maybe<Observable<T>> nested){
+            Maybe<ObservableKind<T>> f = nested.map(ObservableKind::widen);
+            MaybeKind<ObservableKind<T>> x = widen(f);
+            MaybeKind<Higher<observable,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(), Observables.Instances.definitions());
+        }
+        public static <T> Nested<maybe,flowable,T> flowable(Maybe<Flowable<T>> nested){
+            Maybe<FlowableKind<T>> f = nested.map(FlowableKind::widen);
+            MaybeKind<FlowableKind<T>> x = widen(f);
+            MaybeKind<Higher<flowable,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(), Flowables.Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,maybe,T> maybe(Maybe<Maybe<T>> nested){
+            Maybe<MaybeKind<T>> f = nested.map(MaybeKind::widen);
+            MaybeKind<MaybeKind<T>> x = widen(f);
+            MaybeKind<Higher<maybe,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(), Maybes.Instances.definitions());
+        }
+        public static <T> Nested<maybe,single,T> single(Maybe<Single<T>> nested){
+            Maybe<SingleKind<T>> f = nested.map(SingleKind::widen);
+            MaybeKind<SingleKind<T>> x = widen(f);
+            MaybeKind<Higher<single,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(), Singles.Instances.definitions());
+        }
+        public static <T> Nested<maybe,reactiveSeq,T> reactiveSeq(Maybe<ReactiveSeq<T>> nested){
+            MaybeKind<ReactiveSeq<T>> x = widen(nested);
+            MaybeKind<Higher<reactiveSeq,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,Witness.maybe,T> cyclopsMaybe(Maybe<cyclops.control.Maybe<T>> nested){
+            MaybeKind<cyclops.control.Maybe<T>> x = widen(nested);
+            MaybeKind<Higher<Witness.maybe,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(), cyclops.control.Maybe.Instances.definitions());
+        }
+        public static <T> Nested<maybe,eval,T> eval(Maybe<Eval<T>> nested){
+            MaybeKind<Eval<T>> x = widen(nested);
+            MaybeKind<Higher<eval,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<maybe,future,T> future(Maybe<cyclops.async.Future<T>> nested){
+            MaybeKind<cyclops.async.Future<T>> x = widen(nested);
+            MaybeKind<Higher<future,T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<maybe,Higher<xor,S>, P> xor(Maybe<Xor<S, P>> nested){
+            MaybeKind<Xor<S, P>> x = widen(nested);
+            MaybeKind<Higher<Higher<xor,S>, P>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<maybe,Higher<reader,S>, T> reader(Maybe<Reader<S, T>> nested){
+            MaybeKind<Reader<S, T>> x = widen(nested);
+            MaybeKind<Higher<Higher<reader,S>, T>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<maybe,Higher<tryType,S>, P> cyclopsTry(Maybe<cyclops.control.Try<P, S>> nested){
+            MaybeKind<cyclops.control.Try<P, S>> x = widen(nested);
+            MaybeKind<Higher<Higher<tryType,S>, P>> y = (MaybeKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<maybe,optional,T> javaOptional(Maybe<Optional<T>> nested){
+            Maybe<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            MaybeKind<OptionalKind<T>> x = MaybeKind.widen(f);
+
+            MaybeKind<Higher<optional,T>> y = (MaybeKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<maybe,completableFuture,T> javaCompletableFuture(Maybe<CompletableFuture<T>> nested){
+            Maybe<CompletableFutures.CompletableFutureKind<T>> f = nested.map(o -> CompletableFutures.CompletableFutureKind.widen(o));
+            MaybeKind<CompletableFutures.CompletableFutureKind<T>> x = MaybeKind.widen(f);
+            MaybeKind<Higher<completableFuture,T>> y = (MaybeKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<maybe,Witness.stream,T> javaStream(Maybe<java.util.stream.Stream<T>> nested){
+            Maybe<StreamKind<T>> f = nested.map(o -> StreamKind.widen(o));
+            MaybeKind<StreamKind<T>> x = MaybeKind.widen(f);
+            MaybeKind<Higher<Witness.stream,T>> y = (MaybeKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedMaybe{
+        public static <T> Nested<reactiveSeq,maybe,T> reactiveSeq(ReactiveSeq<Maybe<T>> nested){
+            ReactiveSeq<Higher<maybe,T>> x = nested.map(MaybeKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<Witness.maybe,maybe,T> maybe(cyclops.control.Maybe<Maybe<T>> nested){
+            cyclops.control.Maybe<Higher<maybe,T>> x = nested.map(MaybeKind::widenK);
+
+            return Nested.of(x, cyclops.control.Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,maybe,T> eval(Eval<Maybe<T>> nested){
+            Eval<Higher<maybe,T>> x = nested.map(MaybeKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<future,maybe,T> future(cyclops.async.Future<Maybe<T>> nested){
+            cyclops.async.Future<Higher<maybe,T>> x = nested.map(MaybeKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,maybe, P> xor(Xor<S, Maybe<P>> nested){
+            Xor<S, Higher<maybe,P>> x = nested.map(MaybeKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,maybe, T> reader(Reader<S, Maybe<T>> nested){
+
+            Reader<S, Higher<maybe, T>>  x = nested.map(MaybeKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<tryType,S>,maybe, P> cyclopsTry(cyclops.control.Try<Maybe<P>, S> nested){
+            cyclops.control.Try<Higher<maybe,P>, S> x = nested.map(MaybeKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,maybe,T> javaOptional(Optional<Maybe<T>> nested){
+            Optional<Higher<maybe,T>> x = nested.map(MaybeKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,maybe,T> javaCompletableFuture(CompletableFuture<Maybe<T>> nested){
+            CompletableFuture<Higher<maybe,T>> x = nested.thenApply(MaybeKind::widenK);
+
+            return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,maybe,T> javaStream(java.util.stream.Stream<Maybe<T>> nested){
+            java.util.stream.Stream<Higher<maybe,T>> x = nested.map(MaybeKind::widenK);
+
+            return Nested.of(StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 
 }

From 09e8b051fdc22edb6b4e30984dd77f045a3d4357 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 15:03:31 +0100
Subject: [PATCH 19/30] Guava issue

---
 .../cyclops/companion/guava/FluentIterables.java     |  6 ++++++
 .../main/java/cyclops/companion/guava/Optionals.java |  9 ++++++++-
 .../typeclasses/instances/FluentIterablesTest.java   | 12 +++++++++++-
 3 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
index c0bfff6c..88499683 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
@@ -677,6 +677,12 @@ public static <T> Nested<fluentIterable,GuavaWitness.optional,T> optional(Fluent
             FluentIterableKind<Higher<GuavaWitness.optional,T>> y = (FluentIterableKind)x;
             return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
         }
+        public static <T> Nested<fluentIterable,fluentIterable,T> fluentIterable(FluentIterable<FluentIterable<T>> nested){
+            FluentIterable<FluentIterableKind<T>> f = nested.transform(o -> FluentIterableKind.widen(o));
+            FluentIterableKind<FluentIterableKind<T>> x = widen(f);
+            FluentIterableKind<Higher<fluentIterable,T>> y = (FluentIterableKind)x;
+            return Nested.of(y,Instances.definitions(), Instances.definitions());
+        }
 
 
 
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
index f9c92e7d..cc1fbf1a 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
@@ -944,10 +944,17 @@ public static interface OptionalNested{
         public static <T> Nested<optional,fluentIterable,T> fluentIterable(Optional<FluentIterable<T>> nested){
 
             Optional<FluentIterableKind<T>> f = nested.transform(o -> FluentIterableKind.widen(o));
-            OptionalKind<FluentIterable<T>> x = widen(nested);
+            OptionalKind<FluentIterableKind<T>> x = widen(f);
             OptionalKind<Higher<fluentIterable,T>> y = (OptionalKind)x;
             return Nested.of(y,Instances.definitions(), FluentIterables.Instances.definitions());
         }
+        public static <T> Nested<optional,optional,T> optional(Optional<Optional<T>> nested){
+
+            Optional<OptionalKind<T>> f = nested.transform(o -> OptionalKind.widen(o));
+            OptionalKind<OptionalKind<T>> x = widen(f);
+            OptionalKind<Higher<optional,T>> y = (OptionalKind)x;
+            return Nested.of(y,Instances.definitions(), Instances.definitions());
+        }
 
 
 
diff --git a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
index 5ffe207a..78761636 100644
--- a/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
+++ b/cyclops-guava/src/test/java/com/aol/cyclops/guava/hkt/typeclasses/instances/FluentIterablesTest.java
@@ -25,7 +25,17 @@
 import com.google.common.collect.FluentIterable;
 
 public class FluentIterablesTest {
-    
+
+    @Test
+    public void optional(){
+        Higher<fluentIterable, Integer> res = FluentIterables.FluentIterableNested
+                .optional(FluentIterable.of(com.google.common.base.Optional.of(1)))
+                .map(i -> i * 20)
+                .foldsUnsafe()
+                .foldLeft(Monoids.intMax);
+        FluentIterable<Integer> fi = FluentIterableKind.narrow(res);
+        assertThat(fi.get(0),equalTo(20));
+    }
     @Test
     public void nestedOptionalJava(){
         Higher<fluentIterable, Integer> res = FluentIterables.FluentIterableNested

From 868cb8d0b34229184888c8bd9360e918266a24d6 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 15:34:13 +0100
Subject: [PATCH 20/30] Functional Java migration

---
 .../cyclops/functionaljava/hkt/ListKind.java  |  18 +
 .../functionaljava/hkt/NonEmptyListKind.java  |  19 +
 .../functionaljava/hkt/OptionKind.java        |  21 +
 .../functionaljava/hkt/StreamKind.java        |  24 ++
 .../companion/functionaljava/Lists.java       | 121 +++++-
 .../functionaljava/NonEmptyLists.java         |  88 ++++-
 .../companion/functionaljava/Streams.java     | 102 ++++-
 .../hkt/{SetKind.java => HashSetKind.java}    |  68 ++--
 .../java/cyclops/companion/vavr/Arrays.java   |  10 +-
 .../java/cyclops/companion/vavr/Eithers.java  |  19 +-
 .../java/cyclops/companion/vavr/Futures.java  |  20 +-
 .../vavr/{Sets.java => HashSets.java}         | 365 +++++++++---------
 .../java/cyclops/companion/vavr/Lazys.java    |  21 +-
 .../java/cyclops/companion/vavr/Lists.java    |   5 +-
 .../java/cyclops/companion/vavr/Options.java  |  17 +-
 .../java/cyclops/companion/vavr/Queues.java   |  17 +-
 .../java/cyclops/companion/vavr/Streams.java  |  17 +-
 .../java/cyclops/companion/vavr/Trys.java     |  17 +-
 .../main/java/cyclops/monads/VavrWitness.java |  28 +-
 19 files changed, 604 insertions(+), 393 deletions(-)
 rename cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/{SetKind.java => HashSetKind.java} (58%)
 rename cyclops-vavr/src/main/java/cyclops/companion/vavr/{Sets.java => HashSets.java} (59%)

diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
index cba49189..50a6b417 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
@@ -6,8 +6,15 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.collections.mutable.ListX;
+import cyclops.companion.functionaljava.Lists;
 import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.list;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.ListT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import fj.Equal;
 import fj.F;
 import fj.F0;
@@ -45,6 +52,17 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class ListKind<T> implements Higher<list, T> {
 
+    public Active<list,T> allTypeclasses(){
+        return Active.of(this, Lists.Instances.definitions());
+    }
+
+    public <W2,R> Nested<list,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Lists.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> ListT<W, T> liftM(W witness) {
+        return ListT.of(witness.adapter().unit(ListX.fromIterable(boxed)));
+    }
     public <R> ListKind<R> fold(Function<? super List<?  super T>,? extends List<R>> op){
         return widen(op.apply(boxed));
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
index 150a39f8..249728a6 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
@@ -8,8 +8,16 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.collections.mutable.ListX;
+import cyclops.companion.functionaljava.Lists;
+import cyclops.companion.functionaljava.NonEmptyLists;
 import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.nonEmptyList;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.ListT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import fj.F;
 import fj.F2;
 import fj.Ord;
@@ -32,6 +40,17 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class NonEmptyListKind<T> implements Higher<nonEmptyList, T> {
 
+    public Active<nonEmptyList,T> allTypeclasses(){
+        return Active.of(this, NonEmptyLists.Instances.definitions());
+    }
+
+    public <W2,R> Nested<nonEmptyList,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return NonEmptyLists.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> ListT<W, T> liftM(W witness) {
+        return ListT.of(witness.adapter().unit(ListX.fromIterable(boxed)));
+    }
     public <R> NonEmptyListKind<R> fold(Function<? super NonEmptyList<?  super T>,? extends NonEmptyList<R>> op){
         return widen(op.apply(boxed));
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
index 40ea4bbe..68fdad66 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
@@ -8,11 +8,20 @@
 import java.util.function.Supplier;
 
 
+import cyclops.collections.mutable.ListX;
+import cyclops.companion.functionaljava.NonEmptyLists;
+import cyclops.companion.functionaljava.Options;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import com.aol.cyclops2.hkt.Higher;
 import cyclops.control.Maybe;
 import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.option;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.ListT;
+import cyclops.monads.transformers.MaybeT;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import fj.F;
 import fj.F0;
 import fj.F2;
@@ -51,6 +60,18 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final class OptionKind<T> implements Higher<option, T>, Iterable<T> {
     private final Option<T> boxed;
+
+    public Active<option,T> allTypeclasses(){
+        return Active.of(this, Options.Instances.definitions());
+    }
+
+    public <W2,R> Nested<option,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Options.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> MaybeT<W, T> liftM(W witness) {
+        return MaybeT.of(witness.adapter().unit(Maybe.fromIterable(boxed)));
+    }
     public <R> OptionKind<R> fold(Function<? super Option<?  super T>,? extends Option<R>> op){
         return widen(op.apply(boxed));
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
index 0ade4f48..7114c067 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
@@ -6,8 +6,18 @@
 
 
 import com.aol.cyclops2.hkt.Higher;
+import cyclops.companion.functionaljava.Options;
+import cyclops.companion.functionaljava.Streams;
+import cyclops.control.Maybe;
 import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.stream;
+import cyclops.monads.WitnessType;
+import cyclops.monads.transformers.MaybeT;
+import cyclops.monads.transformers.StreamT;
+import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import fj.Equal;
 import fj.F;
 import fj.F0;
@@ -39,6 +49,20 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public  class StreamKind<T> implements Higher<stream, T> {
 
+
+    public Active<stream,T> allTypeclasses(){
+        return Active.of(this, Streams.Instances.definitions());
+    }
+
+    public <W2,R> Nested<stream,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        return Streams.mapM(boxed,fn,defs);
+    }
+
+    public <W extends WitnessType<W>> StreamT<W, T> liftM(W witness) {
+        return StreamT.of(witness.adapter().unit(ReactiveSeq.fromIterable(boxed)));
+    }
+
+
     public static <T> StreamKind<T> stream(final T... values) {
         
         return widen(Stream.stream(values));
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
index 9852e181..b93c4a23 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
@@ -1,6 +1,9 @@
 package cyclops.companion.functionaljava;
 
 import cyclops.collections.mutable.ListX;
+import cyclops.control.Maybe;
+import cyclops.conversion.functionaljava.FromJDK;
+import cyclops.conversion.functionaljava.FromJooqLambda;
 import cyclops.monads.FJWitness.list;
 import com.aol.cyclops.functionaljava.hkt.ListKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -10,17 +13,29 @@
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
 
+import fj.F;
+import fj.P2;
 import fj.data.List;
+import fj.data.Option;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.*;
 
+import static com.aol.cyclops.functionaljava.hkt.ListKind.widen;
+
 
 public class Lists {
    
@@ -296,15 +311,81 @@ public static <T, R1, R> List<R> forEach2(List<? extends T> value1,
                     .map(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+
+    public static <T> Active<list,T> allTypeclasses(List<T> array){
+        return Active.of(widen(array), Lists.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<list,W2,R> mapM(List<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        List<Higher<W2, R>> e = array.map(i->fn.apply(i));
+        ListKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, Lists.Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with Lists
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<list> definitions() {
+            return new InstanceDefinitions<list>() {
+
+                @Override
+                public <T, R> Functor<list> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<list> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<list> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<list> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<list>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<list>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<list>> monadPlus(Monoid<Higher<list, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<list>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<list>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<list>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<list>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
         /**
          *
          * Transform a list, mulitplying every element by 2
@@ -446,7 +527,7 @@ public static <T,R> Monad<list> monad(){
          */
         public static <T,R> MonadZero<list> monadZero(){
 
-            return General.monadZero(monad(), ListKind.widen(List.list()));
+            return General.monadZero(monad(), widen(List.list()));
         }
         /**
          * <pre>
@@ -461,7 +542,7 @@ public static <T,R> MonadZero<list> monadZero(){
          * @return Type class for combining Lists by concatenation
          */
         public static <T> MonadPlus<list> monadPlus(){
-            Monoid<ListKind<T>> m = Monoid.of(ListKind.widen(List.list()), Instances::concat);
+            Monoid<ListKind<T>> m = Monoid.of(widen(List.list()), Instances::concat);
             Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -481,7 +562,11 @@ public static <T> MonadPlus<list> monadPlus(){
          * @param m Monoid to use for combining Lists
          * @return Type class for combining Lists
          */
-        public static <T> MonadPlus<list> monadPlus(Monoid<ListKind<T>> m){
+        public static <T> MonadPlus<list> monadPlus(Monoid<Higher<list,T>> m){
+            Monoid<Higher<list,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<list> monadPlusK(Monoid<ListKind<T>> m){
             Monoid<Higher<list,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -493,12 +578,12 @@ public static <C2,T> Traverse<list> traverse(){
 
             BiFunction<Applicative<C2>,ListKind<Higher<C2, T>>,Higher<C2, ListKind<T>>> sequenceFn = (ap, list) -> {
 
-                Higher<C2,ListKind<T>> identity = ap.unit(ListKind.widen(List.list()));
+                Higher<C2,ListKind<T>> identity = ap.unit(widen(List.list()));
 
                 BiFunction<Higher<C2,ListKind<T>>,Higher<C2,T>,Higher<C2,ListKind<T>>> combineToList =
-                        (acc,next) -> ap.apBiFn(ap.unit((a,b) -> ListKind.widen(ListKind.narrow(a).cons(b))), acc,next);
+                        (acc,next) -> ap.apBiFn(ap.unit((a,b) -> widen(ListKind.narrow(a).cons(b))), acc,next);
 
-                BinaryOperator<Higher<C2,ListKind<T>>> combineLists = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> ListKind.widen(ListKind.narrow(l1).append(ListKind.narrow(l2)))),a,b); ;
+                BinaryOperator<Higher<C2,ListKind<T>>> combineLists = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> widen(ListKind.narrow(l1).append(ListKind.narrow(l2)))),a,b); ;
 
                 return ReactiveSeq.fromIterable(ListKind.narrow(list))
                         .reduce(identity,
@@ -535,21 +620,31 @@ public static <T> Foldable<list> foldable(){
         }
 
         private static  <T> ListKind<T> concat(ListKind<T> l1, ListKind<T> l2){
-            return ListKind.widen(l1.append(ListKind.narrow(l2)));
+            return widen(l1.append(ListKind.narrow(l2)));
 
         }
         private <T> ListKind<T> of(T value){
-            return ListKind.widen(List.list(value));
+            return widen(List.list(value));
         }
         private static <T,R> ListKind<R> ap(ListKind<Function< T, R>> lt, ListKind<T> list){
 
-            return ListKind.widen(lt.zipWith(list.narrow(),(a, b)->a.apply(b)));
+            return widen(lt.zipWith(list.narrow(),(a, b)->a.apply(b)));
         }
         private static <T,R> Higher<list,R> flatMap(Higher<list,T> lt, Function<? super T, ? extends  Higher<list,R>> fn){
-            return ListKind.widen(ListKind.narrow(lt).bind(in->fn.andThen(ListKind::narrow).apply(in)));
+            return widen(ListKind.narrow(lt).bind(in->fn.andThen(ListKind::narrow).apply(in)));
         }
         private static <T,R> ListKind<R> map(ListKind<T> lt, Function<? super T, ? extends R> fn){
-            return ListKind.widen(ListKind.narrow(lt).map(in->fn.apply(in)));
+            return widen(ListKind.narrow(lt).map(in->fn.apply(in)));
+        }
+        public static Unfoldable<list> unfoldable(){
+            return new Unfoldable<list>() {
+                @Override
+                public <R, T> Higher<list, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    F<? super T, Option<P2<R, T>>> f = FromJDK.f1(fn.andThen(FromJDK::option).andThen(o ->o.map(FromJooqLambda::tuple)));
+                    return widen(List.unfold((F<T,Option<P2<R,T>>>)f,b));
+
+                }
+            };
         }
     }
 
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
index 4ce14708..64dfccfe 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
@@ -1,6 +1,11 @@
 package cyclops.companion.functionaljava;
 
+import com.aol.cyclops.functionaljava.hkt.ListKind;
 import cyclops.collections.mutable.ListX;
+import cyclops.control.Maybe;
+import cyclops.conversion.functionaljava.FromJDK;
+import cyclops.conversion.functionaljava.FromJooqLambda;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.nonEmptyList;
 import com.aol.cyclops.functionaljava.hkt.NonEmptyListKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -9,17 +14,30 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import fj.F;
+import fj.P2;
+import fj.data.List;
 import fj.data.NonEmptyList;
+import fj.data.Option;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
+import static com.aol.cyclops.functionaljava.hkt.NonEmptyListKind.widen;
+
 
 public class NonEmptyLists {
    
@@ -159,7 +177,14 @@ public static <T, R1, R> NonEmptyList<R> forEach2(NonEmptyList<? extends T> valu
 
     }
 
-
+    public static <T> Active<nonEmptyList,T> allTypeclasses(NonEmptyList<T> array){
+        return Active.of(widen(array), NonEmptyLists.Instances.definitions());
+    }
+    public static <T,W2,R> Nested<nonEmptyList,W2,R> mapM(NonEmptyList<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        NonEmptyList<Higher<W2, R>> e = array.map(i->fn.apply(i));
+        NonEmptyListKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, Instances.definitions(), defs);
+    }
     /**
      * Companion class for creating Type Class instances for working with NonEmptyLists
      * @author johnmcclean
@@ -168,7 +193,65 @@ public static <T, R1, R> NonEmptyList<R> forEach2(NonEmptyList<? extends T> valu
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<nonEmptyList> definitions() {
+            return new InstanceDefinitions<nonEmptyList>() {
+
+                @Override
+                public <T, R> Functor<nonEmptyList> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<nonEmptyList> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<nonEmptyList> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<nonEmptyList> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<nonEmptyList>> monadZero() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<nonEmptyList>> monadPlus() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<nonEmptyList>> monadPlus(Monoid<Higher<nonEmptyList, T>> m) {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<nonEmptyList>> traverse() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Foldable<nonEmptyList>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<nonEmptyList>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<nonEmptyList>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
         /**
          *
          * Transform a list, mulitplying every element by 2
@@ -332,6 +415,7 @@ private static <T,R> Higher<nonEmptyList,R> flatMap(Higher<nonEmptyList,T> lt, F
         private static <T,R> NonEmptyListKind<R> map(NonEmptyListKind<T> lt, Function<? super T, ? extends R> fn){
             return NonEmptyListKind.widen(NonEmptyListKind.narrow(lt).map(in->fn.apply(in)));
         }
+
     }
 
 
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
index 8e59de5f..f69d6a10 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
@@ -1,5 +1,9 @@
 package cyclops.companion.functionaljava;
 
+import cyclops.control.Maybe;
+import cyclops.conversion.functionaljava.FromJDK;
+import cyclops.conversion.functionaljava.FromJooqLambda;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.stream;
 import com.aol.cyclops.functionaljava.hkt.StreamKind;
 import com.aol.cyclops2.hkt.Higher;
@@ -10,18 +14,31 @@
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import fj.F;
+import fj.P2;
+import fj.data.List;
+import fj.data.Option;
 import fj.data.Stream;
 import lombok.experimental.UtilityClass;
+import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 
+import static com.aol.cyclops.functionaljava.hkt.StreamKind.widen;
+
 
 public class Streams {
    
@@ -297,15 +314,80 @@ public static <T, R1, R> Stream<R> forEach2(Stream<? extends T> value1,
                     .map(in2 -> yieldingFunction.apply(in,  in2));
         });
     }
+    public static <T> Active<stream,T> allTypeclasses(Stream<T> array){
+        return Active.of(StreamKind.widen(array), Instances.definitions());
+    }
+    public static <T,W2,R> Nested<stream,W2,R> mapM(Stream<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Stream<Higher<W2, R>> e = array.map(i->fn.apply(i));
+        StreamKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, Streams.Instances.definitions(), defs);
+    }
 
     /**
      * Companion class for creating Type Class instances for working with Streams
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public class Instances {
-
+        public static InstanceDefinitions<stream> definitions() {
+            return new InstanceDefinitions<stream>() {
+
+                @Override
+                public <T, R> Functor<stream> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<stream> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<stream> applicative() {
+                    return Instances.zippingApplicative();
+                }
+
+                @Override
+                public <T, R> Monad<stream> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<stream>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<stream>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<stream>> monadPlus(Monoid<Higher<stream, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<stream>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<stream>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<stream>> comonad() {
+                    return Maybe.none();
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<stream>> unfoldable() {
+                    return Maybe.just(Instances.unfoldable());
+                }
+            };
+        }
 
         /**
          *
@@ -483,7 +565,11 @@ public static <T> MonadPlus<stream> monadPlus(){
          * @param m Monoid to use for combining Streams
          * @return Type class for combining Streams
          */
-        public static <T> MonadPlus<stream> monadPlus(Monoid<StreamKind<T>> m){
+        public static <T> MonadPlus<stream> monadPlusK(Monoid<StreamKind<T>> m){
+            Monoid<Higher<stream,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<stream> monadPlus(Monoid<Higher<stream,T>> m){
             Monoid<Higher<stream,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -553,6 +639,16 @@ private static <T,R> Higher<stream,R> flatMap(Higher<stream,T> lt, Function<? su
         private static <T,R> StreamKind<R> map(StreamKind<T> lt, Function<? super T, ? extends R> fn){
             return StreamKind.widen(StreamKind.narrow(lt).map(in->fn.apply(in)));
         }
+        public static Unfoldable<stream> unfoldable(){
+            return new Unfoldable<stream>() {
+                @Override
+                public <R, T> Higher<stream, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                    F<? super T, Option<P2<R, T>>> f = FromJDK.f1(fn.andThen(FromJDK::option).andThen(o ->o.map(FromJooqLambda::tuple)));
+                    return StreamKind.widen(Stream.unfold((F<T,Option<P2<R,T>>>)f,b));
+
+                }
+            };
+        }
     }
 
 
diff --git a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/HashSetKind.java
similarity index 58%
rename from cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
rename to cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/HashSetKind.java
index 5a91463f..e020d7e6 100644
--- a/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/SetKind.java
+++ b/cyclops-vavr/src/main/java/com/aol/cyclops/vavr/hkt/HashSetKind.java
@@ -1,15 +1,13 @@
 package com.aol.cyclops.vavr.hkt;
 
 import com.aol.cyclops2.hkt.Higher;
-import cyclops.companion.vavr.Sets;
+import cyclops.companion.vavr.HashSets;
 import cyclops.monads.VavrWitness;
-import cyclops.monads.VavrWitness.set;
-import cyclops.monads.WitnessType;
+import cyclops.monads.VavrWitness.hashSet;
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
-import io.vavr.collection.Array;
 import io.vavr.collection.HashSet;
 import io.vavr.collection.Set;
 import lombok.AccessLevel;
@@ -23,7 +21,7 @@
 /**
  * Simulates Higher Kinded Types for Vavr Set's
  * 
- * SetKind is a Set and a Higher Kinded Type (SetKind.µ,T)
+ * HashSetKind is a Set and a Higher Kinded Type (HashSetKind.µ,T)
  * 
  * @author johnmcclean
  *
@@ -31,21 +29,21 @@
  */
 
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
-public class SetKind<T> implements Higher<set, T>, Publisher<T>, Set<T> {
+public class HashSetKind<T> implements Higher<hashSet, T>, Publisher<T>, Set<T> {
 
-    public static <T> Higher<set,T> widenK(final HashSet<T> completableList) {
+    public static <T> Higher<VavrWitness.hashSet,T> widenK(final HashSet<T> completableList) {
 
-        return new SetKind<>(
+        return new HashSetKind<>(
                 completableList);
     }
-    public Active<set,T> allTypeclasses(){
-        return Active.of(this, Sets.Instances.definitions());
+    public Active<hashSet,T> allTypeclasses(){
+        return Active.of(this, HashSets.Instances.definitions());
     }
 
-    public <W2,R> Nested<set,W2,R> mapM(Function<? super T, ? extends Higher<W2, R>> fn, InstanceDefinitions<W2> defs){
-        return Sets.mapM(boxed,fn,defs);
+    public <W2,R> Nested<VavrWitness.hashSet,W2,R> mapM(Function<? super T, ? extends Higher<W2, R>> fn, InstanceDefinitions<W2> defs){
+        return HashSets.mapM(boxed,fn,defs);
     }
-    public <R> SetKind<R> fold(Function<? super Set<? super T>, ? extends HashSet<R>> op){
+    public <R> HashSetKind<R> fold(Function<? super Set<? super T>, ? extends HashSet<R>> op){
         return widen(op.apply(this));
     }
 
@@ -55,63 +53,63 @@ public <R> SetKind<R> fold(Function<? super Set<? super T>, ? extends HashSet<R>
      * @param value To encode inside a HKT encoded Set
      * @return Completed HKT encoded FSet
      */
-    public static <T> SetKind<T> just(T value) {
+    public static <T> HashSetKind<T> just(T value) {
 
         return widen(HashSet.of(value));
     }
 
-    public static <T> SetKind<T> just(T... values) {
+    public static <T> HashSetKind<T> just(T... values) {
 
         return widen(HashSet.of(values));
     }
 
-    public static <T> SetKind<T> empty() {
+    public static <T> HashSetKind<T> empty() {
         return widen(HashSet.empty());
     }
 
     /**
      * Convert a Set to a simulated HigherKindedType that captures Set nature
-     * and Set element data type separately. Recover via @see SetKind#narrow
+     * and Set element data type separately. Recover via @see HashSetKind#narrow
      * 
-     * If the supplied Set implements SetKind it is returned already, otherwise it
-     * is wrapped into a Set implementation that does implement SetKind
+     * If the supplied Set implements HashSetKind it is returned already, otherwise it
+     * is wrapped into a Set implementation that does implement HashSetKind
      * 
-     * @param completableSet Set to widen to a SetKind
-     * @return SetKind encoding HKT info about Sets
+     * @param completableSet Set to widen to a HashSetKind
+     * @return HashSetKind encoding HKT info about HashSets
      */
-    public static <T> SetKind<T> widen(final HashSet<T> completableSet) {
+    public static <T> HashSetKind<T> widen(final HashSet<T> completableSet) {
 
-        return new SetKind<>(
+        return new HashSetKind<>(
                                 completableSet);
     }
 
     /**
-     * Widen a SetKind nested inside another HKT encoded type
+     * Widen a HashSetKind nested inside another HKT encoded type
      * 
      * @param flux HTK encoded type containing  a Set to widen
      * @return HKT encoded type with a widened Set
      */
-    public static <C2, T> Higher<C2, Higher<set, T>> widen2(Higher<C2, SetKind<T>> flux) {
+    public static <C2, T> Higher<C2, Higher<VavrWitness.hashSet, T>> widen2(Higher<C2, HashSetKind<T>> flux) {
         // a functor could be used (if C2 is a functor / one exists for C2 type)
         // instead of casting
-        // cast seems safer as Higher<set,T> must be a SetKind
+        // cast seems safer as Higher<hashSet,T> must be a HashSetKind
         return (Higher) flux;
     }
 
-    public static <T> SetKind<T> widen(final Publisher<T> completableSet) {
+    public static <T> HashSetKind<T> widen(final Publisher<T> completableSet) {
 
-        return new SetKind<>(
+        return new HashSetKind<>(
                                 HashSet.ofAll((Iterable<T>)ReactiveSeq.fromPublisher(completableSet)));
     }
 
     /**
-     * Convert the raw Higher Kinded Type for SetKind types into the SetKind type definition class
+     * Convert the raw Higher Kinded Type for HashSetKind types into the HashSetKind type definition class
      * 
-     * @param future HKT encoded set into a SetKind
-     * @return SetKind
+     * @param future HKT encoded hashSet into a HashSetKind
+     * @return HashSetKind
      */
-    public static <T> SetKind<T> narrowK(final Higher<set, T> future) {
-        return (SetKind<T>) future;
+    public static <T> HashSetKind<T> narrowK(final Higher<hashSet, T> future) {
+        return (HashSetKind<T>) future;
     }
 
     /**
@@ -120,9 +118,9 @@ public static <T> SetKind<T> narrowK(final Higher<set, T> future) {
      * @param set Type Constructor to convert back into narrowed type
      * @return Set from Higher Kinded Type
      */
-    public static <T> HashSet<T> narrow(final Higher<set, T> set) {
+    public static <T> HashSet<T> narrow(final Higher<VavrWitness.hashSet, T> set) {
 
-        return ((SetKind<T>) set).narrow();
+        return ((HashSetKind<T>) set).narrow();
 
     }
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
index b208357c..ad75dade 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
@@ -2,7 +2,6 @@
 
 
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -10,8 +9,6 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
@@ -20,8 +17,6 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 
-import cyclops.monads.VavrWitness.*;
-import cyclops.monads.VavrWitness.*;
 import cyclops.monads.VavrWitness.either;
 import cyclops.monads.VavrWitness.future;
 import cyclops.monads.VavrWitness.list;
@@ -42,7 +37,6 @@
 import io.vavr.control.Option;
 import io.vavr.control.Try;
 import lombok.experimental.UtilityClass;
-import org.jooq.lambda.tuple.Tuple;
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
@@ -698,8 +692,8 @@ public static <T> Nested<array,array,T> array(Array<Array<T>> nested){
         public static <T> Nested<array,vector,T> vector(Array<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<array,VavrWitness.set,T> set(Array<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<array,hashSet,T> set(Array<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<array,reactiveSeq,T> reactiveSeq(Array<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
index 7e703173..66bde44e 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
@@ -5,7 +5,6 @@
 import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -13,12 +12,9 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
@@ -27,25 +23,15 @@
 import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.EitherKind;
 import com.aol.cyclops.vavr.hkt.ListKind;
-import com.aol.cyclops2.hkt.Higher;
 import cyclops.companion.Monoids;
-import cyclops.control.Maybe;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
-import cyclops.monads.*;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
 import com.aol.cyclops2.types.Value;
 import com.aol.cyclops2.types.anyM.AnyMValue;
 import cyclops.collections.mutable.ListX;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.VavrWitness.either;
 import cyclops.monads.transformers.XorT;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.comonad.ComonadByPure;
 import cyclops.typeclasses.foldable.Foldable;
@@ -57,7 +43,6 @@
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
-import java.nio.file.WatchEvent;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
@@ -808,8 +793,8 @@ public static <L, T> Nested<Higher<either, L>, vector, T> vector(Either<L, Vecto
                 return Nested.of(widen(nested.map(VectorKind::widen)), Instances.definitions(), Vectors.Instances.definitions());
             }
 
-            public static <L, T> Nested<Higher<either, L>, VavrWitness.set, T> set(Either<L, HashSet<T>> nested) {
-                return Nested.of(widen(nested.map(SetKind::widen)), Instances.definitions(), Sets.Instances.definitions());
+            public static <L, T> Nested<Higher<either, L>, hashSet, T> set(Either<L, HashSet<T>> nested) {
+                return Nested.of(widen(nested.map(HashSetKind::widen)), Instances.definitions(), HashSets.Instances.definitions());
             }
 
             public static <L, T> Nested<Higher<either, L>, reactiveSeq, T> reactiveSeq(Either<L, ReactiveSeq<T>> nested) {
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
index feaa3f6f..b2576996 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Futures.java
@@ -7,7 +7,6 @@
 import io.vavr.collection.*;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -15,12 +14,9 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
@@ -30,27 +26,16 @@
 import com.aol.cyclops.vavr.hkt.ArrayKind;
 import com.aol.cyclops.vavr.hkt.ListKind;
 import com.aol.cyclops2.react.Status;
-import com.aol.cyclops2.react.collectors.lazy.Blocker;
-import cyclops.control.Maybe;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
-import cyclops.monads.*;
 import cyclops.monads.VavrWitness.future;
 import com.aol.cyclops.vavr.hkt.FutureKind;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
-import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.Value;
 import com.aol.cyclops2.types.anyM.AnyMValue;
 import cyclops.collections.mutable.ListX;
 import cyclops.companion.Monoids;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.transformers.FutureT;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -71,7 +56,6 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 
 
 import static com.aol.cyclops.vavr.hkt.FutureKind.widen;
@@ -1087,8 +1071,8 @@ public static <T> Nested<future,array,T> array(Future<Array<T>> nested){
         public static <T> Nested<future,vector,T> vector(Future<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<future,VavrWitness.set,T> set(Future<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<future,hashSet,T> set(Future<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<future,reactiveSeq,T> reactiveSeq(Future<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/HashSets.java
similarity index 59%
rename from cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
rename to cyclops-vavr/src/main/java/cyclops/companion/vavr/HashSets.java
index bebe861b..eb866b3e 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Sets.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/HashSets.java
@@ -1,21 +1,15 @@
 package cyclops.companion.vavr;
 
+import cyclops.control.*;
 import cyclops.monads.VavrWitness.queue;
 import io.vavr.Lazy;
 import io.vavr.collection.*;
+import io.vavr.collection.Stream;
 import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
-import cyclops.control.Eval;
-import cyclops.control.Maybe;
-import cyclops.control.Reader;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
@@ -26,24 +20,16 @@
 import cyclops.monads.Witness.*;
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.*;
-import com.aol.cyclops.vavr.hkt.SetKind;
-import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
+import com.aol.cyclops.vavr.hkt.HashSetKind;
 
 import cyclops.control.Maybe;
 import cyclops.control.Xor;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.hashSet;
-import cyclops.monads.VavrWitness.set;
 import cyclops.monads.WitnessType;
 
 import cyclops.monads.XorM;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -52,6 +38,7 @@
 import cyclops.typeclasses.monad.*;
 import io.vavr.collection.HashSet;
 import io.vavr.collection.Set;
+import io.vavr.control.Try;
 import lombok.experimental.UtilityClass;
 import org.jooq.lambda.tuple.Tuple2;
 
@@ -59,19 +46,19 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.function.*;
 
-import static com.aol.cyclops.vavr.hkt.SetKind.widen;
+import static com.aol.cyclops.vavr.hkt.HashSetKind.widen;
 
 
-public class Sets {
+public class HashSets {
 
-    public static  <W1,T> Coproduct<W1,set,T> coproduct(HashSet<T> type, InstanceDefinitions<W1> def1){
+    public static  <W1,T> Coproduct<W1,hashSet,T> coproduct(HashSet<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
-    public static  <W1 extends WitnessType<W1>,T> XorM<W1,set,T> xorM(HashSet<T> type){
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,hashSet,T> xorM(HashSet<T> type){
         return XorM.right(anyM(type));
     }
-    public static <T> AnyMSeq<set,T> anyM(HashSet<T> option) {
-        return AnyM.ofSeq(option, set.INSTANCE);
+    public static <T> AnyMSeq<hashSet,T> anyM(HashSet<T> option) {
+        return AnyM.ofSeq(option, hashSet.INSTANCE);
     }
     /**
      * Perform a For Comprehension over a Set, accepting 3 generating functions.
@@ -80,7 +67,7 @@ public static <T> AnyMSeq<set,T> anyM(HashSet<T> option) {
      *  <pre>
      * {@code
      *
-     *   import static cyclops.Sets.forEach4;
+     *   import static cyclops.HashSets.forEach4;
      *
     forEach4(IntSet.range(1,10).boxed(),
     a-> Set.iterate(a,i->i+1).limit(10),
@@ -178,7 +165,7 @@ public static <T1, T2, T3, R1, R2, R3, R> Set<R> forEach4(Set<? extends T1> valu
      * <pre>
      * {@code
      *
-     * import static Sets.forEach3;
+     * import static HashSets.forEach3;
      *
      * forEach(IntSet.range(1,10).boxed(),
     a-> Set.iterate(a,i->i+1).limit(10),
@@ -220,7 +207,7 @@ public static <T1, T2, R1, R2, R> Set<R> forEach3(Set<? extends T1> value1,
      * <pre>
      * {@code
      *
-     * import static Sets.forEach;
+     * import static HashSets.forEach;
      *
      * forEach(IntSet.range(1,10).boxed(),
     a-> Set.iterate(a,i->i+1).limit(10),
@@ -266,7 +253,7 @@ public static <T1, T2, R1, R2, R> Set<R> forEach3(Set<? extends T1> value1,
      * <pre>
      * {@code
      *
-     *  import static Sets.forEach2;
+     *  import static HashSets.forEach2;
      *  forEach(IntSet.range(1, 10).boxed(),
      *          i -> Set.range(i, 10), Tuple::tuple)
     .forEach(System.out::println);
@@ -302,7 +289,7 @@ public static <T, R1, R> Set<R> forEach2(Set<? extends T> value1,
      * <pre>
      * {@code
      *
-     *   import static Sets.forEach2;
+     *   import static HashSets.forEach2;
      *
      *   forEach(IntSet.range(1, 10).boxed(),
      *           i -> Set.range(i, 10),
@@ -343,87 +330,87 @@ public static <T, R1, R> Set<R> forEach2(Set<? extends T> value1,
         });
     }
 
-    public static <T> Active<set,T> allTypeclasses(HashSet<T> array){
-        return Active.of(widen(array), Sets.Instances.definitions());
+    public static <T> Active<hashSet,T> allTypeclasses(HashSet<T> array){
+        return Active.of(widen(array), HashSets.Instances.definitions());
     }
-    public static <T,W2,R> Nested<set,W2,R> mapM(HashSet<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+    public static <T,W2,R> Nested<hashSet,W2,R> mapM(HashSet<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         HashSet<Higher<W2, R>> e = array.map(fn);
-        SetKind<Higher<W2, R>> lk = widen(e);
-        return Nested.of(lk, Sets.Instances.definitions(), defs);
+        HashSetKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, HashSets.Instances.definitions(), defs);
     }
     /**
-     * Companion class for creating Type Class instances for working with Sets
+     * Companion class for creating Type Class instances for working with HashSets
      *
      */
     @UtilityClass
     public static class Instances {
 
-        public static InstanceDefinitions<set> definitions() {
-            return new InstanceDefinitions<set>() {
+        public static InstanceDefinitions<hashSet> definitions() {
+            return new InstanceDefinitions<hashSet>() {
 
                 @Override
-                public <T, R> Functor<set> functor() {
+                public <T, R> Functor<hashSet> functor() {
                     return Instances.functor();
                 }
 
                 @Override
-                public <T> Pure<set> unit() {
+                public <T> Pure<hashSet> unit() {
                     return Instances.unit();
                 }
 
                 @Override
-                public <T, R> Applicative<set> applicative() {
+                public <T, R> Applicative<hashSet> applicative() {
                     return Instances.zippingApplicative();
                 }
 
                 @Override
-                public <T, R> Monad<set> monad() {
+                public <T, R> Monad<hashSet> monad() {
                     return Instances.monad();
                 }
 
                 @Override
-                public <T, R> Maybe<MonadZero<set>> monadZero() {
+                public <T, R> Maybe<MonadZero<hashSet>> monadZero() {
                     return Maybe.just(Instances.monadZero());
                 }
 
                 @Override
-                public <T> Maybe<MonadPlus<set>> monadPlus() {
+                public <T> Maybe<MonadPlus<hashSet>> monadPlus() {
                     return Maybe.just(Instances.monadPlus());
                 }
 
                 @Override
-                public <T> Maybe<MonadPlus<set>> monadPlus(Monoid<Higher<set, T>> m) {
+                public <T> Maybe<MonadPlus<hashSet>> monadPlus(Monoid<Higher<hashSet, T>> m) {
                     return Maybe.just(Instances.monadPlus(m));
                 }
 
                 @Override
-                public <C2, T> Maybe<Traverse<set>> traverse() {
+                public <C2, T> Maybe<Traverse<hashSet>> traverse() {
                     return Maybe.just(Instances.traverse());
                 }
 
                 @Override
-                public <T> Maybe<Foldable<set>> foldable() {
+                public <T> Maybe<Foldable<hashSet>> foldable() {
                     return Maybe.just(Instances.foldable());
                 }
 
                 @Override
-                public <T> Maybe<Comonad<set>> comonad() {
+                public <T> Maybe<Comonad<hashSet>> comonad() {
                     return Maybe.none();
                 }
 
                 @Override
-                public <T> Maybe<Unfoldable<set>> unfoldable() {
+                public <T> Maybe<Unfoldable<hashSet>> unfoldable() {
                     return Maybe.just(Instances.unfoldable());
                 }
             };
         }
         /**
          *
-         * Transform a set, mulitplying every element by 2
+         * Transform a hashSet, mulitplying every element by 2
          *
          * <pre>
          * {@code
-         *  SetKind<Integer> set = Sets.functor().map(i->i*2, SetKind.widen(Set.of(1,2,3));
+         *  HashSetKind<Integer> hashSet = HashSets.functor().map(i->i*2, HashSetKind.widen(Set.of(1,2,3));
          *
          *  //[2,4,6]
          *
@@ -431,30 +418,30 @@ public <T> Maybe<Unfoldable<set>> unfoldable() {
          * }
          * </pre>
          *
-         * An example fluent api working with Sets
+         * An example fluent api working with HashSets
          * <pre>
          * {@code
-         *   SetKind<Integer> set = Sets.unit()
+         *   HashSetKind<Integer> hashSet = HashSets.unit()
         .unit("hello")
-        .then(h->Sets.functor().map((String v) ->v.length(), h))
-        .convert(SetKind::narrowK);
+        .then(h->HashSets.functor().map((String v) ->v.length(), h))
+        .convert(HashSetKind::narrowK);
          *
          * }
          * </pre>
          *
          *
-         * @return A functor for Sets
+         * @return A functor for HashSets
          */
-        public static <T,R>Functor<set> functor(){
-            BiFunction<SetKind<T>,Function<? super T, ? extends R>,SetKind<R>> map = Instances::map;
+        public static <T,R>Functor<hashSet> functor(){
+            BiFunction<HashSetKind<T>,Function<? super T, ? extends R>,HashSetKind<R>> map = Instances::map;
             return General.functor(map);
         }
         /**
          * <pre>
          * {@code
-         * SetKind<String> set = Sets.unit()
+         * HashSetKind<String> hashSet = HashSets.unit()
         .unit("hello")
-        .convert(SetKind::narrowK);
+        .convert(HashSetKind::narrowK);
 
         //Set.of("hello"))
          *
@@ -462,19 +449,19 @@ public static <T,R>Functor<set> functor(){
          * </pre>
          *
          *
-         * @return A factory for Sets
+         * @return A factory for HashSets
          */
-        public static <T> Pure<set> unit(){
-            return General.<set,T>unit(Instances::of);
+        public static <T> Pure<hashSet> unit(){
+            return General.<hashSet,T>unit(Instances::of);
         }
         /**
          *
          * <pre>
          * {@code
-         * import static com.aol.cyclops.hkt.jdk.SetKind.widen;
+         * import static com.aol.cyclops.hkt.jdk.HashSetKind.widen;
          * import static com.aol.cyclops.util.function.Lambda.l1;
          *
-        Sets.zippingApplicative()
+        HashSets.zippingApplicative()
         .ap(widen(Set.of(l1(this::multiplyByTwo))),widen(Set.of(1,2,3)));
          *
          * //[2,4,6]
@@ -485,15 +472,15 @@ public static <T> Pure<set> unit(){
          * Example fluent API
          * <pre>
          * {@code
-         * SetKind<Function<Integer,Integer>> setFn =Sets.unit()
+         * HashSetKind<Function<Integer,Integer>> setFn =HashSets.unit()
          *                                                  .unit(Lambda.l1((Integer i) ->i*2))
-         *                                                  .convert(SetKind::narrowK);
+         *                                                  .convert(HashSetKind::narrowK);
 
-        SetKind<Integer> set = Sets.unit()
+        HashSetKind<Integer> hashSet = HashSets.unit()
         .unit("hello")
-        .then(h->Sets.functor().map((String v) ->v.length(), h))
-        .then(h->Sets.zippingApplicative().ap(setFn, h))
-        .convert(SetKind::narrowK);
+        .then(h->HashSets.functor().map((String v) ->v.length(), h))
+        .then(h->HashSets.zippingApplicative().ap(setFn, h))
+        .convert(HashSetKind::narrowK);
 
         //Set.of("hello".length()*2))
          *
@@ -501,51 +488,51 @@ public static <T> Pure<set> unit(){
          * </pre>
          *
          *
-         * @return A zipper for Sets
+         * @return A zipper for HashSets
          */
-        public static <T,R> Applicative<set> zippingApplicative(){
-            BiFunction<SetKind< Function<T, R>>,SetKind<T>,SetKind<R>> ap = Instances::ap;
+        public static <T,R> Applicative<hashSet> zippingApplicative(){
+            BiFunction<HashSetKind< Function<T, R>>,HashSetKind<T>,HashSetKind<R>> ap = Instances::ap;
             return General.applicative(functor(), unit(), ap);
         }
         /**
          *
          * <pre>
          * {@code
-         * import static com.aol.cyclops.hkt.jdk.SetKind.widen;
-         * SetKind<Integer> set  = Sets.monad()
+         * import static com.aol.cyclops.hkt.jdk.HashSetKind.widen;
+         * HashSetKind<Integer> hashSet  = HashSets.monad()
         .flatMap(i->widen(SetX.range(0,i)), widen(Set.of(1,2,3)))
-        .convert(SetKind::narrowK);
+        .convert(HashSetKind::narrowK);
          * }
          * </pre>
          *
          * Example fluent API
          * <pre>
          * {@code
-         *    SetKind<Integer> set = Sets.unit()
+         *    HashSetKind<Integer> hashSet = HashSets.unit()
         .unit("hello")
-        .then(h->Sets.monad().flatMap((String v) ->Sets.unit().unit(v.length()), h))
-        .convert(SetKind::narrowK);
+        .then(h->HashSets.monad().flatMap((String v) ->HashSets.unit().unit(v.length()), h))
+        .convert(HashSetKind::narrowK);
 
         //Set.of("hello".length())
          *
          * }
          * </pre>
          *
-         * @return Type class with monad functions for Sets
+         * @return Type class with monad functions for HashSets
          */
-        public static <T,R> Monad<set> monad(){
+        public static <T,R> Monad<hashSet> monad(){
 
-            BiFunction<Higher<set,T>,Function<? super T, ? extends Higher<set,R>>,Higher<set,R>> flatMap = Instances::flatMap;
+            BiFunction<Higher<hashSet,T>,Function<? super T, ? extends Higher<hashSet,R>>,Higher<hashSet,R>> flatMap = Instances::flatMap;
             return General.monad(zippingApplicative(), flatMap);
         }
         /**
          *
          * <pre>
          * {@code
-         *  SetKind<String> set = Sets.unit()
+         *  HashSetKind<String> hashSet = HashSets.unit()
         .unit("hello")
-        .then(h->Sets.monadZero().filter((String t)->t.startsWith("he"), h))
-        .convert(SetKind::narrowK);
+        .then(h->HashSets.monadZero().filter((String t)->t.startsWith("he"), h))
+        .convert(HashSetKind::narrowK);
 
         //Set.of("hello"));
          *
@@ -555,64 +542,64 @@ public static <T,R> Monad<set> monad(){
          *
          * @return A filterable monad (with default value)
          */
-        public static <T,R> MonadZero<set> monadZero(){
-            BiFunction<Higher<set,T>,Predicate<? super T>,Higher<set,T>> filter = Instances::filter;
-            Supplier<Higher<set, T>> zero = ()-> widen(HashSet.empty());
-            return General.<set,T,R>monadZero(monad(), zero,filter);
+        public static <T,R> MonadZero<hashSet> monadZero(){
+            BiFunction<Higher<hashSet,T>,Predicate<? super T>,Higher<hashSet,T>> filter = Instances::filter;
+            Supplier<Higher<hashSet, T>> zero = ()-> widen(HashSet.empty());
+            return General.<hashSet,T,R>monadZero(monad(), zero,filter);
         }
         /**
          * <pre>
          * {@code
-         *  SetKind<Integer> set = Sets.<Integer>monadPlus()
-        .plus(SetKind.widen(Set.of()), SetKind.widen(Set.of(10)))
-        .convert(SetKind::narrowK);
+         *  HashSetKind<Integer> hashSet = HashSets.<Integer>monadPlus()
+        .plus(HashSetKind.widen(Set.of()), HashSetKind.widen(Set.of(10)))
+        .convert(HashSetKind::narrowK);
         //Set.of(10))
          *
          * }
          * </pre>
-         * @return Type class for combining Sets by concatenation
+         * @return Type class for combining HashSets by concatenation
          */
-        public static <T> MonadPlus<set> monadPlus(){
-            Monoid<SetKind<T>> m = Monoid.of(widen(HashSet.<T>empty()), Instances::concat);
-            Monoid<Higher<set,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<hashSet> monadPlus(){
+            Monoid<HashSetKind<T>> m = Monoid.of(widen(HashSet.<T>empty()), Instances::concat);
+            Monoid<Higher<hashSet,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
         /**
          *
          * <pre>
          * {@code
-         *  Monoid<SetKind<Integer>> m = Monoid.of(SetKind.widen(Set.of()), (a,b)->a.isEmpty() ? b : a);
-        SetKind<Integer> set = Sets.<Integer>monadPlus(m)
-        .plus(SetKind.widen(Set.of(5)), SetKind.widen(Set.of(10)))
-        .convert(SetKind::narrowK);
+         *  Monoid<HashSetKind<Integer>> m = Monoid.of(HashSetKind.widen(Set.of()), (a,b)->a.isEmpty() ? b : a);
+        HashSetKind<Integer> hashSet = HashSets.<Integer>monadPlus(m)
+        .plus(HashSetKind.widen(Set.of(5)), HashSetKind.widen(Set.of(10)))
+        .convert(HashSetKind::narrowK);
         //Set.of(5))
          *
          * }
          * </pre>
          *
-         * @param m Monoid to use for combining Sets
-         * @return Type class for combining Sets
+         * @param m Monoid to use for combining HashSets
+         * @return Type class for combining HashSets
          */
-        public static <T> MonadPlus<set> monadPlus(Monoid<Higher<set,T>> m){
-            Monoid<Higher<set,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<hashSet> monadPlus(Monoid<Higher<hashSet,T>> m){
+            Monoid<Higher<hashSet,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
-        public static <T> MonadPlus<set> monadPlusK(Monoid<SetKind<T>> m){
-            Monoid<Higher<set,T>> m2= (Monoid)m;
+        public static <T> MonadPlus<hashSet> monadPlusK(Monoid<HashSetKind<T>> m){
+            Monoid<Higher<hashSet,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
 
         /**
          * @return Type class for traversables with traverse / sequence operations
          */
-        public static <C2,T> Traverse<set> traverse(){
-            BiFunction<Applicative<C2>,SetKind<Higher<C2, T>>,Higher<C2, SetKind<T>>> sequenceFn = (ap, set) -> {
+        public static <C2,T> Traverse<hashSet> traverse(){
+            BiFunction<Applicative<C2>,HashSetKind<Higher<C2, T>>,Higher<C2, HashSetKind<T>>> sequenceFn = (ap, set) -> {
 
-                Higher<C2,SetKind<T>> identity = ap.unit(widen(HashSet.empty()));
+                Higher<C2,HashSetKind<T>> identity = ap.unit(widen(HashSet.empty()));
 
-                BiFunction<Higher<C2,SetKind<T>>,Higher<C2,T>,Higher<C2,SetKind<T>>> combineToSet =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> concat(a, SetKind.just(b))),acc,next);
+                BiFunction<Higher<C2,HashSetKind<T>>,Higher<C2,T>,Higher<C2,HashSetKind<T>>> combineToSet =   (acc, next) -> ap.apBiFn(ap.unit((a, b) -> concat(a, HashSetKind.just(b))),acc,next);
 
-                BinaryOperator<Higher<C2,SetKind<T>>> combineSets = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return concat(l1,l2);}),a,b); ;
+                BinaryOperator<Higher<C2,HashSetKind<T>>> combineSets = (a, b)-> ap.apBiFn(ap.unit((l1, l2)-> { return concat(l1,l2);}),a,b); ;
 
                 return ReactiveSeq.fromIterable(set).reduce(identity,
                         combineToSet,
@@ -620,8 +607,8 @@ public static <C2,T> Traverse<set> traverse(){
 
 
             };
-            BiFunction<Applicative<C2>,Higher<set,Higher<C2, T>>,Higher<C2, Higher<set,T>>> sequenceNarrow  =
-                    (a,b) -> SetKind.widen2(sequenceFn.apply(a, SetKind.narrowK(b)));
+            BiFunction<Applicative<C2>,Higher<hashSet,Higher<C2, T>>,Higher<C2, Higher<hashSet,T>>> sequenceNarrow  =
+                    (a,b) -> HashSetKind.widen2(sequenceFn.apply(a, HashSetKind.narrowK(b)));
             return General.traverse(zippingApplicative(), sequenceNarrow);
         }
 
@@ -629,8 +616,8 @@ public static <C2,T> Traverse<set> traverse(){
          *
          * <pre>
          * {@code
-         * int sum  = Sets.foldable()
-        .foldLeft(0, (a,b)->a+b, SetKind.widen(Set.of(1,2,3,4)));
+         * int sum  = HashSets.foldable()
+        .foldLeft(0, (a,b)->a+b, HashSetKind.widen(Set.of(1,2,3,4)));
 
         //10
          *
@@ -640,34 +627,34 @@ public static <C2,T> Traverse<set> traverse(){
          *
          * @return Type class for folding / reduction operations
          */
-        public static <T> Foldable<set> foldable(){
-            BiFunction<Monoid<T>,Higher<set,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(SetKind.narrow(l)).foldRight(m);
-            BiFunction<Monoid<T>,Higher<set,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(SetKind.narrow(l)).reduce(m);
+        public static <T> Foldable<hashSet> foldable(){
+            BiFunction<Monoid<T>,Higher<hashSet,T>,T> foldRightFn =  (m, l)-> ReactiveSeq.fromIterable(HashSetKind.narrow(l)).foldRight(m);
+            BiFunction<Monoid<T>,Higher<hashSet,T>,T> foldLeftFn = (m, l)-> ReactiveSeq.fromIterable(HashSetKind.narrow(l)).reduce(m);
             return General.foldable(foldRightFn, foldLeftFn);
         }
 
-        private static  <T> SetKind<T> concat(SetKind<T> l1, SetKind<T> l2){
+        private static  <T> HashSetKind<T> concat(HashSetKind<T> l1, HashSetKind<T> l2){
             return widen(l1.addAll(l2));
         }
-        private <T> SetKind<T> of(T value){
+        private <T> HashSetKind<T> of(T value){
             return widen(HashSet.of(value));
         }
-        private static <T,R> SetKind<R> ap(SetKind<Function< T, R>> lt, SetKind<T> set){
+        private static <T,R> HashSetKind<R> ap(HashSetKind<Function< T, R>> lt, HashSetKind<T> set){
             return widen(lt.toReactiveSeq().zip(set,(a, b)->a.apply(b)));
         }
-        private static <T,R> Higher<set,R> flatMap(Higher<set,T> lt, Function<? super T, ? extends  Higher<set,R>> fn){
-            return widen(SetKind.narrowK(lt).flatMap(fn.andThen(SetKind::narrowK)));
+        private static <T,R> Higher<hashSet,R> flatMap(Higher<hashSet,T> lt, Function<? super T, ? extends  Higher<hashSet,R>> fn){
+            return widen(HashSetKind.narrowK(lt).flatMap(fn.andThen(HashSetKind::narrowK)));
         }
-        private static <T,R> SetKind<R> map(SetKind<T> lt, Function<? super T, ? extends R> fn){
+        private static <T,R> HashSetKind<R> map(HashSetKind<T> lt, Function<? super T, ? extends R> fn){
             return widen(lt.map(fn));
         }
-        private static <T> SetKind<T> filter(Higher<set,T> lt, Predicate<? super T> fn){
-            return widen(SetKind.narrow(lt).filter(fn));
+        private static <T> HashSetKind<T> filter(Higher<hashSet,T> lt, Predicate<? super T> fn){
+            return widen(HashSetKind.narrow(lt).filter(fn));
         }
-        public static Unfoldable<set> unfoldable(){
-            return new Unfoldable<set>() {
+        public static Unfoldable<hashSet> unfoldable(){
+            return new Unfoldable<hashSet>() {
                 @Override
-                public <R, T> Higher<set, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
+                public <R, T> Higher<hashSet, R> unfold(T b, Function<? super T, Optional<Tuple2<R, T>>> fn) {
                     return widen(ReactiveSeq.unfold(b,fn).collect(HashSet.collector()));
 
                 }
@@ -677,86 +664,86 @@ public <R, T> Higher<set, R> unfold(T b, Function<? super T, Optional<Tuple2<R,
     public static interface SetNested{
 
 
-        public static <T> Nested<set,lazy,T> lazy(HashSet<Lazy<T>> type){
+        public static <T> Nested<hashSet,lazy,T> lazy(HashSet<Lazy<T>> type){
             return Nested.of(widen(type.map(LazyKind::widen)),Instances.definitions(),Lazys.Instances.definitions());
         }
-        public static <T> Nested<set,VavrWitness.tryType,T> setTry(HashSet<Try<T>> type){
+        public static <T> Nested<hashSet,VavrWitness.tryType,T> setTry(HashSet<Try<T>> type){
             return Nested.of(widen(type.map(TryKind::widen)),Instances.definitions(),Trys.Instances.definitions());
         }
-        public static <T> Nested<set,VavrWitness.future,T> future(HashSet<Future<T>> type){
+        public static <T> Nested<hashSet,VavrWitness.future,T> future(HashSet<Future<T>> type){
             return Nested.of(widen(type.map(FutureKind::widen)),Instances.definitions(),Futures.Instances.definitions());
         }
-        public static <T> Nested<set,queue,T>  queue(HashSet<Queue<T>> nested){
+        public static <T> Nested<hashSet,queue,T>  queue(HashSet<Queue<T>> nested){
             return Nested.of(widen(nested.map(QueueKind::widen)),Instances.definitions(),Queues.Instances.definitions());
         }
-        public static <L, R> Nested<set,Higher<VavrWitness.either,L>, R> either(HashSet<Either<L, R>> nested){
+        public static <L, R> Nested<hashSet,Higher<VavrWitness.either,L>, R> either(HashSet<Either<L, R>> nested){
             return Nested.of(widen(nested.map(EitherKind::widen)),Instances.definitions(),Eithers.Instances.definitions());
         }
-        public static <T> Nested<set,VavrWitness.stream,T> stream(HashSet<Stream<T>> nested){
+        public static <T> Nested<hashSet,VavrWitness.stream,T> stream(HashSet<Stream<T>> nested){
             return Nested.of(widen(nested.map(StreamKind::widen)),Instances.definitions(),Streams.Instances.definitions());
         }
-        public static <T> Nested<set,VavrWitness.list,T> list(HashSet<List<T>> nested){
+        public static <T> Nested<hashSet,VavrWitness.list,T> list(HashSet<List<T>> nested){
             return Nested.of(widen(nested.map(ListKind::widen)), Instances.definitions(),Lists.Instances.definitions());
         }
-        public static <T> Nested<set,array,T> array(HashSet<Array<T>> nested){
+        public static <T> Nested<hashSet,array,T> array(HashSet<Array<T>> nested){
             return Nested.of(widen(nested.map(ArrayKind::widen)),Instances.definitions(),Arrays.Instances.definitions());
         }
-        public static <T> Nested<set,vector,T> vector(HashSet<Vector<T>> nested){
+        public static <T> Nested<hashSet,vector,T> vector(HashSet<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<set,VavrWitness.set,T> set(HashSet<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<hashSet,hashSet,T> set(HashSet<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
-        public static <T> Nested<set,reactiveSeq,T> reactiveSeq(HashSet<ReactiveSeq<T>> nested){
-            SetKind<ReactiveSeq<T>> x = widen(nested);
-            SetKind<Higher<reactiveSeq,T>> y = (SetKind)x;
+        public static <T> Nested<hashSet,reactiveSeq,T> reactiveSeq(HashSet<ReactiveSeq<T>> nested){
+            HashSetKind<ReactiveSeq<T>> x = widen(nested);
+            HashSetKind<Higher<reactiveSeq,T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
         }
 
-        public static <T> Nested<set,maybe,T> maybe(HashSet<Maybe<T>> nested){
-            SetKind<Maybe<T>> x = widen(nested);
-            SetKind<Higher<maybe,T>> y = (SetKind)x;
+        public static <T> Nested<hashSet,maybe,T> maybe(HashSet<Maybe<T>> nested){
+            HashSetKind<Maybe<T>> x = widen(nested);
+            HashSetKind<Higher<maybe,T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
         }
-        public static <T> Nested<set,eval,T> eval(HashSet<Eval<T>> nested){
-            SetKind<Eval<T>> x = widen(nested);
-            SetKind<Higher<eval,T>> y = (SetKind)x;
+        public static <T> Nested<hashSet,eval,T> eval(HashSet<Eval<T>> nested){
+            HashSetKind<Eval<T>> x = widen(nested);
+            HashSetKind<Higher<eval,T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
         }
-        public static <T> Nested<set,Witness.future,T> cyclopsFuture(HashSet<cyclops.async.Future<T>> nested){
-            SetKind<cyclops.async.Future<T>> x = widen(nested);
-            SetKind<Higher<Witness.future,T>> y = (SetKind)x;
+        public static <T> Nested<hashSet,Witness.future,T> cyclopsFuture(HashSet<cyclops.async.Future<T>> nested){
+            HashSetKind<cyclops.async.Future<T>> x = widen(nested);
+            HashSetKind<Higher<Witness.future,T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
         }
-        public static <S, P> Nested<set,Higher<xor,S>, P> xor(HashSet<Xor<S, P>> nested){
-            SetKind<Xor<S, P>> x = widen(nested);
-            SetKind<Higher<Higher<xor,S>, P>> y = (SetKind)x;
+        public static <S, P> Nested<hashSet,Higher<xor,S>, P> xor(HashSet<Xor<S, P>> nested){
+            HashSetKind<Xor<S, P>> x = widen(nested);
+            HashSetKind<Higher<Higher<xor,S>, P>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
         }
-        public static <S,T> Nested<set,Higher<reader,S>, T> reader(HashSet<Reader<S, T>> nested){
-            SetKind<Reader<S, T>> x = widen(nested);
-            SetKind<Higher<Higher<reader,S>, T>> y = (SetKind)x;
+        public static <S,T> Nested<hashSet,Higher<reader,S>, T> reader(HashSet<Reader<S, T>> nested){
+            HashSetKind<Reader<S, T>> x = widen(nested);
+            HashSetKind<Higher<Higher<reader,S>, T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
         }
-        public static <S extends Throwable, P> Nested<set,Higher<Witness.tryType,S>, P> cyclopsTry(HashSet<cyclops.control.Try<P, S>> nested){
-            SetKind<cyclops.control.Try<P, S>> x = widen(nested);
-            SetKind<Higher<Higher<Witness.tryType,S>, P>> y = (SetKind)x;
+        public static <S extends Throwable, P> Nested<hashSet,Higher<Witness.tryType,S>, P> cyclopsTry(HashSet<cyclops.control.Try<P, S>> nested){
+            HashSetKind<cyclops.control.Try<P, S>> x = widen(nested);
+            HashSetKind<Higher<Higher<Witness.tryType,S>, P>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
         }
-        public static <T> Nested<set,optional,T> setal(HashSet<Optional<T>> nested){
-            SetKind<Optional<T>> x = widen(nested);
-            SetKind<Higher<optional,T>> y = (SetKind)x;
+        public static <T> Nested<hashSet,optional,T> setal(HashSet<Optional<T>> nested){
+            HashSetKind<Optional<T>> x = widen(nested);
+            HashSetKind<Higher<optional,T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(), Optionals.Instances.definitions());
         }
-        public static <T> Nested<set,completableFuture,T> completableSet(HashSet<CompletableFuture<T>> nested){
-            SetKind<CompletableFuture<T>> x = widen(nested);
-            SetKind<Higher<completableFuture,T>> y = (SetKind)x;
+        public static <T> Nested<hashSet,completableFuture,T> completableSet(HashSet<CompletableFuture<T>> nested){
+            HashSetKind<CompletableFuture<T>> x = widen(nested);
+            HashSetKind<Higher<completableFuture,T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(), CompletableFutures.Instances.definitions());
         }
-        public static <T> Nested<set,Witness.stream,T> javaStream(HashSet<java.util.stream.Stream<T>> nested){
-            SetKind<java.util.stream.Stream<T>> x = widen(nested);
-            SetKind<Higher<Witness.stream,T>> y = (SetKind)x;
+        public static <T> Nested<hashSet,Witness.stream,T> javaStream(HashSet<java.util.stream.Stream<T>> nested){
+            HashSetKind<java.util.stream.Stream<T>> x = widen(nested);
+            HashSetKind<Higher<Witness.stream,T>> y = (HashSetKind)x;
             return Nested.of(y,Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
         }
 
@@ -764,54 +751,54 @@ public static <T> Nested<set,Witness.stream,T> javaStream(HashSet<java.util.stre
 
     }
     public static interface NestedSet{
-        public static <T> Nested<reactiveSeq,set,T> reactiveSeq(ReactiveSeq<HashSet<T>> nested){
-            ReactiveSeq<Higher<set,T>> x = nested.map(SetKind::widenK);
+        public static <T> Nested<reactiveSeq,hashSet,T> reactiveSeq(ReactiveSeq<HashSet<T>> nested){
+            ReactiveSeq<Higher<hashSet,T>> x = nested.map(HashSetKind::widenK);
             return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
         }
 
-        public static <T> Nested<maybe,set,T> maybe(Maybe<HashSet<T>> nested){
-            Maybe<Higher<set,T>> x = nested.map(SetKind::widenK);
+        public static <T> Nested<maybe,hashSet,T> maybe(Maybe<HashSet<T>> nested){
+            Maybe<Higher<hashSet,T>> x = nested.map(HashSetKind::widenK);
 
             return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
         }
-        public static <T> Nested<eval,set,T> eval(Eval<HashSet<T>> nested){
-            Eval<Higher<set,T>> x = nested.map(SetKind::widenK);
+        public static <T> Nested<eval,hashSet,T> eval(Eval<HashSet<T>> nested){
+            Eval<Higher<hashSet,T>> x = nested.map(HashSetKind::widenK);
 
             return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
         }
-        public static <T> Nested<Witness.future,set,T> cyclopsFuture(cyclops.async.Future<HashSet<T>> nested){
-            cyclops.async.Future<Higher<set,T>> x = nested.map(SetKind::widenK);
+        public static <T> Nested<Witness.future,hashSet,T> cyclopsFuture(cyclops.async.Future<HashSet<T>> nested){
+            cyclops.async.Future<Higher<hashSet,T>> x = nested.map(HashSetKind::widenK);
 
             return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
         }
-        public static <S, P> Nested<Higher<xor,S>,set, P> xor(Xor<S, HashSet<P>> nested){
-            Xor<S, Higher<set,P>> x = nested.map(SetKind::widenK);
+        public static <S, P> Nested<Higher<xor,S>,hashSet, P> xor(Xor<S, HashSet<P>> nested){
+            Xor<S, Higher<hashSet,P>> x = nested.map(HashSetKind::widenK);
 
             return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
         }
-        public static <S,T> Nested<Higher<reader,S>,set, T> reader(Reader<S, HashSet<T>> nested){
+        public static <S,T> Nested<Higher<reader,S>,hashSet, T> reader(Reader<S, HashSet<T>> nested){
 
-            Reader<S, Higher<set, T>>  x = nested.map(SetKind::widenK);
+            Reader<S, Higher<hashSet, T>>  x = nested.map(HashSetKind::widenK);
 
             return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
         }
-        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,set, P> cyclopsTry(cyclops.control.Try<HashSet<P>, S> nested){
-            cyclops.control.Try<Higher<set,P>, S> x = nested.map(SetKind::widenK);
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,hashSet, P> cyclopsTry(cyclops.control.Try<HashSet<P>, S> nested){
+            cyclops.control.Try<Higher<hashSet,P>, S> x = nested.map(HashSetKind::widenK);
 
             return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
         }
-        public static <T> Nested<optional,set,T> setal(Optional<HashSet<T>> nested){
-            Optional<Higher<set,T>> x = nested.map(SetKind::widenK);
+        public static <T> Nested<optional,hashSet,T> setal(Optional<HashSet<T>> nested){
+            Optional<Higher<hashSet,T>> x = nested.map(HashSetKind::widenK);
 
             return  Nested.of(Optionals.OptionalKind.widen(x), Optionals.Instances.definitions(), Instances.definitions());
         }
-        public static <T> Nested<completableFuture,set,T> completableSet(CompletableFuture<HashSet<T>> nested){
-            CompletableFuture<Higher<set,T>> x = nested.thenApply(SetKind::widenK);
+        public static <T> Nested<completableFuture,hashSet,T> completableSet(CompletableFuture<HashSet<T>> nested){
+            CompletableFuture<Higher<hashSet,T>> x = nested.thenApply(HashSetKind::widenK);
 
             return Nested.of(CompletableFutures.CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
         }
-        public static <T> Nested<Witness.stream,set,T> javaStream(java.util.stream.Stream<HashSet<T>> nested){
-            java.util.stream.Stream<Higher<set,T>> x = nested.map(SetKind::widenK);
+        public static <T> Nested<Witness.stream,hashSet,T> javaStream(java.util.stream.Stream<HashSet<T>> nested){
+            java.util.stream.Stream<Higher<hashSet,T>> x = nested.map(HashSetKind::widenK);
 
             return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
         }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
index 87184228..15c9e64d 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
@@ -8,7 +8,6 @@
 import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -16,12 +15,8 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
-import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
@@ -30,25 +25,13 @@
 import cyclops.typeclasses.*;
 
 import com.aol.cyclops.vavr.hkt.EitherKind;
-import cyclops.control.Maybe;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import com.aol.cyclops.vavr.hkt.LazyKind;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
-import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.Value;
 import cyclops.collections.mutable.ListX;
-import cyclops.control.Eval;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.function.Reducer;
-import cyclops.monads.*;
 import cyclops.monads.transformers.EvalT;
-import cyclops.monads.transformers.XorT;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -814,8 +797,8 @@ public static <T> Nested<lazy,array,T> array(Lazy<Array<T>> nested){
         public static <T> Nested<lazy,vector,T> vector(Lazy<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<lazy,VavrWitness.set,T> set(Lazy<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<lazy,hashSet,T> set(Lazy<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<lazy,reactiveSeq,T> reactiveSeq(Lazy<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
index 1a897762..8f9ec146 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
@@ -1,7 +1,6 @@
 package cyclops.companion.vavr;
 
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.collections.immutable.VectorX;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -696,8 +695,8 @@ public static <T> Nested<list,array,T> array(List<Array<T>> nested){
         public static <T> Nested<list,vector,T> vector(List<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<list,VavrWitness.set,T> set(List<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<list,hashSet,T> set(List<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<list,reactiveSeq,T> reactiveSeq(List<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
index 5834912a..5f4539ac 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
@@ -5,7 +5,6 @@
 import io.vavr.collection.*;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -13,12 +12,9 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
@@ -26,29 +22,20 @@
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.FutureKind;
-import cyclops.control.Maybe;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.option;
 import com.aol.cyclops.vavr.hkt.OptionKind;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
-import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.Value;
 import com.aol.cyclops2.types.anyM.AnyMValue;
 import cyclops.collections.mutable.ListX;
 import cyclops.companion.Monoids;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
 import cyclops.monads.WitnessType;
 import cyclops.monads.XorM;
 import cyclops.monads.transformers.OptionalT;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -971,8 +958,8 @@ public static <T> Nested<option,array,T> array(Option<Array<T>> nested){
         public static <T> Nested<option,vector,T> vector(Option<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<option,VavrWitness.set,T> set(Option<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<option,hashSet,T> set(Option<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<option,reactiveSeq,T> reactiveSeq(Option<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
index 2f9f4079..53d0d1e5 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
@@ -6,7 +6,6 @@
 import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -14,8 +13,6 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
@@ -27,22 +24,12 @@
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.ListKind;
-import cyclops.control.Maybe;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.queue;
 import com.aol.cyclops.vavr.hkt.QueueKind;
-import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.monads.WitnessType;
 import cyclops.monads.XorM;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -707,8 +694,8 @@ public static <T> Nested<queue,array,T> array(Queue<Array<T>> nested){
         public static <T> Nested<queue,vector,T> vector(Queue<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<queue,VavrWitness.set,T> set(Queue<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<queue,hashSet,T> set(Queue<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<queue,reactiveSeq,T> reactiveSeq(Queue<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index 1edcb564..5dcba227 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -7,7 +7,6 @@
 import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -15,8 +14,6 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
@@ -28,22 +25,12 @@
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.ListKind;
-import cyclops.control.Maybe;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.stream;
 import com.aol.cyclops.vavr.hkt.StreamKind;
-import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
 import cyclops.monads.WitnessType;
 import cyclops.monads.XorM;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -707,8 +694,8 @@ public static <T> Nested<stream,array,T> array(Stream<Array<T>> nested){
         public static <T> Nested<stream,vector,T> vector(Stream<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<stream,VavrWitness.set,T> set(Stream<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<stream,hashSet,T> set(Stream<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<stream,reactiveSeq,T> reactiveSeq(Stream<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
index 35a92ede..6b6f1719 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
@@ -7,7 +7,6 @@
 import io.vavr.concurrent.Future;
 import io.vavr.control.*;
 import com.aol.cyclops.vavr.hkt.*;
-import cyclops.VavrConverters;
 import cyclops.companion.CompletableFutures;
 import cyclops.companion.Optionals;
 import cyclops.control.Eval;
@@ -15,12 +14,9 @@
 import cyclops.control.Reader;
 import cyclops.control.Xor;
 import cyclops.conversion.vavr.FromCyclopsReact;
-import cyclops.conversion.vavr.FromJDK;
-import cyclops.conversion.vavr.FromJooqLambda;
 import cyclops.monads.*;
 import cyclops.monads.VavrWitness.*;
 import com.aol.cyclops2.hkt.Higher;
-import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
@@ -28,27 +24,18 @@
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.*;
 import com.aol.cyclops.vavr.hkt.TryKind;
-import com.aol.cyclops2.hkt.Higher;
 import cyclops.companion.Monoids;
-import cyclops.control.Maybe;
-import cyclops.control.Xor;
-import cyclops.conversion.vavr.FromCyclopsReact;
 import cyclops.conversion.vavr.ToCyclopsReact;
 import cyclops.monads.VavrWitness;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
 import com.aol.cyclops2.types.Value;
 import com.aol.cyclops2.types.anyM.AnyMValue;
 import cyclops.collections.mutable.ListX;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Monoid;
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
 import cyclops.monads.VavrWitness.tryType;
 import cyclops.monads.WitnessType;
 import cyclops.monads.XorM;
-import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -948,8 +935,8 @@ public static <T> Nested<tryType,array,T> array(Try<Array<T>> nested){
         public static <T> Nested<tryType,vector,T> vector(Try<Vector<T>> nested){
             return Nested.of(widen(nested.map(VectorKind::widen)),Instances.definitions(),Vectors.Instances.definitions());
         }
-        public static <T> Nested<tryType,VavrWitness.set,T> set(Try<HashSet<T>> nested){
-            return Nested.of(widen(nested.map(SetKind::widen)),Instances.definitions(),Sets.Instances.definitions());
+        public static <T> Nested<tryType,hashSet,T> set(Try<HashSet<T>> nested){
+            return Nested.of(widen(nested.map(HashSetKind::widen)),Instances.definitions(), HashSets.Instances.definitions());
         }
 
         public static <T> Nested<tryType,reactiveSeq,T> reactiveSeq(Try<ReactiveSeq<T>> nested){
diff --git a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
index 6c674d9d..8c283724 100644
--- a/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
+++ b/cyclops-vavr/src/main/java/cyclops/monads/VavrWitness.java
@@ -188,31 +188,7 @@ public Traversable emptyTraversable() {
         }
 
     }
-    public static enum hashSet implements TraversableWitness<hashSet> {
-        INSTANCE;
-
-        @Override
-        public FunctionalAdapter<hashSet> adapter() {
-            return new TraversableAdapter(INSTANCE){
-
-                @Override
-                public Traversable traversableFromIterable(Iterable value) {
-                    return HashSet.ofAll(value);
-                }
-
-                @Override
-                public Traversable singletonTraversable(Object value) {
-                    return HashSet.of(value);
-                }
 
-                @Override
-                public Traversable emptyTraversable() {
-                    return HashSet.empty();
-                }
-            };
-        }
-
-    }
     static interface OptionWitness<W extends VavrWitness.OptionWitness<W>>  extends WitnessType<W> {
 
     }
@@ -270,11 +246,11 @@ public FunctionalAdapter<lazy> adapter() {
         }
 
     }
-    public static enum set implements TraversableWitness<set> {
+    public static enum hashSet implements TraversableWitness<hashSet> {
         INSTANCE;
 
         @Override
-        public FunctionalAdapter<set> adapter() {
+        public FunctionalAdapter<hashSet> adapter() {
             return new TraversableAdapter(INSTANCE){
 
                 @Override

From 15b73fc5eb717d0c220b01a0808552f9f6c4e07d Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 16:04:51 +0100
Subject: [PATCH 21/30] Functional Java migration

---
 .../functionaljava/hkt/EitherKind.java        |   6 +
 .../cyclops/functionaljava/hkt/ListKind.java  |   5 +
 .../functionaljava/hkt/NonEmptyListKind.java  |   4 +
 .../functionaljava/hkt/OptionKind.java        |   4 +
 .../functionaljava/hkt/StreamKind.java        |   4 +
 .../companion/functionaljava/Lists.java       | 161 ++++++++++-
 .../functionaljava/NonEmptyLists.java         | 161 ++++++++++-
 .../companion/functionaljava/Options.java     | 257 +++++++++++++++++-
 .../companion/functionaljava/Streams.java     | 162 ++++++++++-
 9 files changed, 742 insertions(+), 22 deletions(-)

diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
index 6c9d031d..3a25dce9 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
@@ -7,6 +7,7 @@
 import cyclops.companion.functionaljava.Eithers;
 import cyclops.control.Xor;
 import cyclops.conversion.functionaljava.ToCyclopsReact;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.either;
 import cyclops.monads.Witness;
 import cyclops.monads.WitnessType;
@@ -43,6 +44,11 @@ public static <L, R> Either<L, R> narrowK2(final Higher2<either, L, R> xor) {
     public static <L, R> Either<L, R> narrowK(final Higher<Higher<either, L>, R> either) {
         return (Either<L, R>)either;
     }
+    public static <L,T> Higher<Higher<either,L>,T> widenK(final Either<L,T> completableList) {
+
+        return new EitherKind<>(
+                completableList);
+    }
     public Active<Higher<either,L>,R> allTypeclasses(){
         return Active.of(this, Eithers.Instances.definitions());
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
index 50a6b417..14f1f7cf 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
@@ -56,6 +56,11 @@ public Active<list,T> allTypeclasses(){
         return Active.of(this, Lists.Instances.definitions());
     }
 
+    public static <T> Higher<list,T> widenK(final List<T> completableList) {
+
+        return new ListKind<>(
+                completableList);
+    }
     public <W2,R> Nested<list,W2,R> mapM(Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
         return Lists.mapM(boxed,fn,defs);
     }
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
index 249728a6..517645d5 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/NonEmptyListKind.java
@@ -58,7 +58,11 @@ public static<T> NonEmptyListKind<T> of(T first, T...v){
         
         return widen(NonEmptyList.fromList(List.list(v).cons(first)).some());
     }
+    public static <T> Higher<nonEmptyList,T> widenK(final NonEmptyList<T> completableList) {
 
+        return new NonEmptyListKind<T>(
+                completableList);
+    }
     /**
      * Convert a NonEmptyList to a simulated HigherKindedType that captures NonEmptyList nature
      * and NonEmptyList element data type separately. Recover via @see NonEmptyListKind#narrow
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
index 68fdad66..2657d659 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/OptionKind.java
@@ -75,7 +75,11 @@ public <W extends WitnessType<W>> MaybeT<W, T> liftM(W witness) {
     public <R> OptionKind<R> fold(Function<? super Option<?  super T>,? extends Option<R>> op){
         return widen(op.apply(boxed));
     }
+    public static <T> Higher<option,T> widenK(final Option<T> completableList) {
 
+        return new OptionKind<>(
+                completableList);
+    }
     /**
      * @return An HKT encoded empty Option
      */
diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
index 7114c067..f2a865af 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/StreamKind.java
@@ -62,7 +62,11 @@ public <W extends WitnessType<W>> StreamT<W, T> liftM(W witness) {
         return StreamT.of(witness.adapter().unit(ReactiveSeq.fromIterable(boxed)));
     }
 
+    public static <T> Higher<stream,T> widenK(final Stream<T> completableList) {
 
+        return new StreamKind<>(
+                completableList);
+    }
     public static <T> StreamKind<T> stream(final T... values) {
         
         return widen(Stream.stream(values));
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
index b93c4a23..7a11c11b 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Lists.java
@@ -1,17 +1,29 @@
 package cyclops.companion.functionaljava;
 
+import com.aol.cyclops.functionaljava.hkt.*;
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.*;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.companion.Streams;
+import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.conversion.functionaljava.FromJDK;
 import cyclops.conversion.functionaljava.FromJooqLambda;
+import cyclops.monads.FJWitness;
 import cyclops.monads.FJWitness.list;
-import com.aol.cyclops.functionaljava.hkt.ListKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.FJWitness.nonEmptyList;
+import cyclops.monads.FJWitness.option;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
@@ -26,12 +38,12 @@
 
 import fj.F;
 import fj.P2;
-import fj.data.List;
-import fj.data.Option;
+import fj.data.*;
 import lombok.experimental.UtilityClass;
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.*;
 
 import static com.aol.cyclops.functionaljava.hkt.ListKind.widen;
@@ -647,6 +659,149 @@ public <R, T> Higher<list, R> unfold(T b, Function<? super T, Optional<Tuple2<R,
             };
         }
     }
+    public static interface ListNested {
+        public static <T> Nested<list,option,T> option(List<Option<T>> nested){
+            List<OptionKind<T>> f = nested.map(OptionKind::widen);
+            ListKind<OptionKind<T>> x = widen(f);
+            ListKind<Higher<option,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(), Options.Instances.definitions());
+        }
+        public static <L,T> Nested<list,Higher<FJWitness.either,L>,T> either(List<Either<L,T>> nested){
+            List<EitherKind<L,T>> f = nested.map(EitherKind::widen);
+            ListKind<EitherKind<L,T>> x = widen(f);
+            ListKind<Higher<Higher<FJWitness.either,L>,T>> y = (ListKind)x;
+
+            return Nested.of(y,Instances.definitions(), Eithers.Instances.definitions());
+        }
+        public static <T> Nested<list,nonEmptyList,T> nonEmptyList(List<NonEmptyList<T>> nested){
+            List<NonEmptyListKind<T>> f = nested.map(NonEmptyListKind::widen);
+            ListKind<NonEmptyListKind<T>> x = widen(f);
+            ListKind<Higher<nonEmptyList,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),NonEmptyLists.Instances.definitions());
+        }
+        public static <T> Nested<list,FJWitness.stream,T> stream(List<Stream<T>> nested){
+            List<StreamKind<T>> f = nested.map(StreamKind::widen);
+            ListKind<StreamKind<T>> x = widen(f);
+            ListKind<Higher<FJWitness.stream,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.companion.functionaljava.Streams.Instances.definitions());
+        }
+        public static <T> Nested<list,list,T> list(List<List<T>> nested){
+            List<ListKind<T>> f = nested.map(ListKind::widen);
+            ListKind<ListKind<T>> x = widen(f);
+            ListKind<Higher<list,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Lists.Instances.definitions());
+        }
+
+        public static <T> Nested<list,reactiveSeq,T> reactiveSeq(List<ReactiveSeq<T>> nested){
+            ListKind<ReactiveSeq<T>> x = widen(nested);
+            ListKind<Higher<reactiveSeq,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<list,Witness.maybe,T> maybe(List<Maybe<T>> nested){
+            ListKind<Maybe<T>> x = widen(nested);
+            ListKind<Higher<Witness.maybe,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<list,Witness.eval,T> eval(List<Eval<T>> nested){
+            ListKind<Eval<T>> x = widen(nested);
+            ListKind<Higher<Witness.eval,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<list,Witness.future,T> future(List<cyclops.async.Future<T>> nested){
+            ListKind<cyclops.async.Future<T>> x = widen(nested);
+            ListKind<Higher<Witness.future,T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<list,Higher<xor,S>, P> xor(List<Xor<S, P>> nested){
+            ListKind<Xor<S, P>> x = widen(nested);
+            ListKind<Higher<Higher<xor,S>, P>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<list,Higher<reader,S>, T> reader(List<Reader<S, T>> nested){
+            ListKind<Reader<S, T>> x = widen(nested);
+            ListKind<Higher<Higher<reader,S>, T>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<list,Higher<Witness.tryType,S>, P> cyclopsTry(List<cyclops.control.Try<P, S>> nested){
+            ListKind<cyclops.control.Try<P, S>> x = widen(nested);
+            ListKind<Higher<Higher<Witness.tryType,S>, P>> y = (ListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<list,optional,T> javaOptional(List<Optional<T>> nested){
+            List<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            ListKind<OptionalKind<T>> x = ListKind.widen(f);
 
+            ListKind<Higher<optional,T>> y = (ListKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<list,completableFuture,T> javaCompletableFuture(List<CompletableFuture<T>> nested){
+            List<CompletableFutureKind<T>> f = nested.map(o -> CompletableFutureKind.widen(o));
+            ListKind<CompletableFutureKind<T>> x = ListKind.widen(f);
+            ListKind<Higher<completableFuture,T>> y = (ListKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<list,Witness.stream,T> javaStream(List<java.util.stream.Stream<T>> nested){
+            List<Streams.StreamKind<T>> f = nested.map(o -> Streams.StreamKind.widen(o));
+            ListKind<Streams.StreamKind<T>> x = ListKind.widen(f);
+            ListKind<Higher<Witness.stream,T>> y = (ListKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedList{
+        public static <T> Nested<reactiveSeq,list,T> reactiveSeq(ReactiveSeq<List<T>> nested){
+            ReactiveSeq<Higher<list,T>> x = nested.map(ListKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,list,T> maybe(Maybe<List<T>> nested){
+            Maybe<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,list,T> eval(Eval<List<T>> nested){
+            Eval<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,list,T> future(cyclops.async.Future<List<T>> nested){
+            cyclops.async.Future<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,list, P> xor(Xor<S, List<P>> nested){
+            Xor<S, Higher<list,P>> x = nested.map(ListKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,list, T> reader(Reader<S, List<T>> nested){
+
+            Reader<S, Higher<list, T>>  x = nested.map(ListKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,list, P> cyclopsTry(cyclops.control.Try<List<P>, S> nested){
+            cyclops.control.Try<Higher<list,P>, S> x = nested.map(ListKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,list,T> javaOptional(Optional<List<T>> nested){
+            Optional<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,list,T> javaCompletableFuture(CompletableFuture<List<T>> nested){
+            CompletableFuture<Higher<list,T>> x = nested.thenApply(ListKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,list,T> javaStream(java.util.stream.Stream<List<T>> nested){
+            java.util.stream.Stream<Higher<list,T>> x = nested.map(ListKind::widenK);
+
+            return Nested.of(Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 
 }
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
index 64dfccfe..b8e824a5 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/NonEmptyLists.java
@@ -1,19 +1,30 @@
 package cyclops.companion.functionaljava;
 
-import com.aol.cyclops.functionaljava.hkt.ListKind;
+import com.aol.cyclops.functionaljava.hkt.*;
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Optionals;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.conversion.functionaljava.FromJDK;
 import cyclops.conversion.functionaljava.FromJooqLambda;
 import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.list;
 import cyclops.monads.FJWitness.nonEmptyList;
-import com.aol.cyclops.functionaljava.hkt.NonEmptyListKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
 import cyclops.function.Fn3;
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.FJWitness.option;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
+import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
@@ -26,6 +37,7 @@
 import cyclops.typeclasses.monad.*;
 import fj.F;
 import fj.P2;
+import fj.data.Either;
 import fj.data.List;
 import fj.data.NonEmptyList;
 import fj.data.Option;
@@ -33,6 +45,7 @@
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
@@ -417,6 +430,150 @@ private static <T,R> NonEmptyListKind<R> map(NonEmptyListKind<T> lt, Function<?
         }
 
     }
+    public static interface NonEmptyListNested {
+        public static <T> Nested<nonEmptyList,nonEmptyList,T> nonEmptyList(NonEmptyList<NonEmptyList<T>> nested){
+            NonEmptyList<NonEmptyListKind<T>> f = nested.map(NonEmptyListKind::widen);
+            NonEmptyListKind<NonEmptyListKind<T>> x = widen(f);
+            NonEmptyListKind<Higher<nonEmptyList,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(), NonEmptyLists.Instances.definitions());
+        }
+        public static <L,T> Nested<nonEmptyList,Higher<FJWitness.either,L>,T> either(NonEmptyList<Either<L,T>> nested){
+            NonEmptyList<EitherKind<L,T>> f = nested.map(EitherKind::widen);
+            NonEmptyListKind<EitherKind<L,T>> x = widen(f);
+            NonEmptyListKind<Higher<Higher<FJWitness.either,L>,T>> y = (NonEmptyListKind)x;
+
+            return Nested.of(y,Instances.definitions(), Eithers.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,option,T> option(NonEmptyList<Option<T>> nested){
+            NonEmptyList<OptionKind<T>> f = nested.map(OptionKind::widen);
+            NonEmptyListKind<OptionKind<T>> x = widen(f);
+            NonEmptyListKind<Higher<option,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),Options.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,FJWitness.stream,T> stream(NonEmptyList<fj.data.Stream<T>> nested){
+            NonEmptyList<StreamKind<T>> f = nested.map(StreamKind::widen);
+            NonEmptyListKind<StreamKind<T>> x = widen(f);
+            NonEmptyListKind<Higher<FJWitness.stream,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.companion.functionaljava.Streams.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,list,T> list(NonEmptyList<List<T>> nested){
+            NonEmptyList<ListKind<T>> f = nested.map(ListKind::widen);
+            NonEmptyListKind<ListKind<T>> x = widen(f);
+            NonEmptyListKind<Higher<list,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),Lists.Instances.definitions());
+        }
+
+        public static <T> Nested<nonEmptyList,reactiveSeq,T> reactiveSeq(NonEmptyList<ReactiveSeq<T>> nested){
+            NonEmptyListKind<ReactiveSeq<T>> x = widen(nested);
+            NonEmptyListKind<Higher<reactiveSeq,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<nonEmptyList,Witness.maybe,T> maybe(NonEmptyList<Maybe<T>> nested){
+            NonEmptyListKind<Maybe<T>> x = widen(nested);
+            NonEmptyListKind<Higher<Witness.maybe,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,Witness.eval,T> eval(NonEmptyList<Eval<T>> nested){
+            NonEmptyListKind<Eval<T>> x = widen(nested);
+            NonEmptyListKind<Higher<Witness.eval,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,Witness.future,T> future(NonEmptyList<cyclops.async.Future<T>> nested){
+            NonEmptyListKind<cyclops.async.Future<T>> x = widen(nested);
+            NonEmptyListKind<Higher<Witness.future,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<nonEmptyList,Higher<xor,S>, P> xor(NonEmptyList<Xor<S, P>> nested){
+            NonEmptyListKind<Xor<S, P>> x = widen(nested);
+            NonEmptyListKind<Higher<Higher<xor,S>, P>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<nonEmptyList,Higher<reader,S>, T> reader(NonEmptyList<Reader<S, T>> nested){
+            NonEmptyListKind<Reader<S, T>> x = widen(nested);
+            NonEmptyListKind<Higher<Higher<reader,S>, T>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<nonEmptyList,Higher<Witness.tryType,S>, P> cyclopsTry(NonEmptyList<cyclops.control.Try<P, S>> nested){
+            NonEmptyListKind<cyclops.control.Try<P, S>> x = widen(nested);
+            NonEmptyListKind<Higher<Higher<Witness.tryType,S>, P>> y = (NonEmptyListKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,optional,T> javaOptional(NonEmptyList<Optional<T>> nested){
+            NonEmptyList<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            NonEmptyListKind<OptionalKind<T>> x = NonEmptyListKind.widen(f);
+
+            NonEmptyListKind<Higher<optional,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,completableFuture,T> javaCompletableFuture(NonEmptyList<CompletableFuture<T>> nested){
+            NonEmptyList<CompletableFutureKind<T>> f = nested.map(o -> CompletableFutureKind.widen(o));
+            NonEmptyListKind<CompletableFutureKind<T>> x = NonEmptyListKind.widen(f);
+            NonEmptyListKind<Higher<completableFuture,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<nonEmptyList,Witness.stream,T> javaStream(NonEmptyList<java.util.stream.Stream<T>> nested){
+            NonEmptyList<cyclops.companion.Streams.StreamKind<T>> f = nested.map(o -> cyclops.companion.Streams.StreamKind.widen(o));
+            NonEmptyListKind<cyclops.companion.Streams.StreamKind<T>> x = NonEmptyListKind.widen(f);
+            NonEmptyListKind<Higher<Witness.stream,T>> y = (NonEmptyListKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedNonEmptyList{
+        public static <T> Nested<reactiveSeq,nonEmptyList,T> reactiveSeq(ReactiveSeq<NonEmptyList<T>> nested){
+            ReactiveSeq<Higher<nonEmptyList,T>> x = nested.map(NonEmptyListKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,nonEmptyList,T> maybe(Maybe<NonEmptyList<T>> nested){
+            Maybe<Higher<nonEmptyList,T>> x = nested.map(NonEmptyListKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,nonEmptyList,T> eval(Eval<NonEmptyList<T>> nested){
+            Eval<Higher<nonEmptyList,T>> x = nested.map(NonEmptyListKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,nonEmptyList,T> future(cyclops.async.Future<NonEmptyList<T>> nested){
+            cyclops.async.Future<Higher<nonEmptyList,T>> x = nested.map(NonEmptyListKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,nonEmptyList, P> xor(Xor<S, NonEmptyList<P>> nested){
+            Xor<S, Higher<nonEmptyList,P>> x = nested.map(NonEmptyListKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,nonEmptyList, T> reader(Reader<S, NonEmptyList<T>> nested){
+
+            Reader<S, Higher<nonEmptyList, T>>  x = nested.map(NonEmptyListKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,nonEmptyList, P> cyclopsTry(cyclops.control.Try<NonEmptyList<P>, S> nested){
+            cyclops.control.Try<Higher<nonEmptyList,P>, S> x = nested.map(NonEmptyListKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,nonEmptyList,T> javaNonEmptyListal(Optional<NonEmptyList<T>> nested){
+            Optional<Higher<nonEmptyList,T>> x = nested.map(NonEmptyListKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,nonEmptyList,T> javaCompletableFuture(CompletableFuture<NonEmptyList<T>> nested){
+            CompletableFuture<Higher<nonEmptyList,T>> x = nested.thenApply(NonEmptyListKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,nonEmptyList,T> javaStream(java.util.stream.Stream<NonEmptyList<T>> nested){
+            java.util.stream.Stream<Higher<nonEmptyList,T>> x = nested.map(NonEmptyListKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 
 
 }
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
index c9ba327b..0c0a14de 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
@@ -1,13 +1,21 @@
 package cyclops.companion.functionaljava;
 
 
+import com.aol.cyclops.functionaljava.hkt.*;
 import cyclops.collections.mutable.ListX;
-import cyclops.monads.FJ;
-import cyclops.monads.FJWitness;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Optionals;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.control.Eval;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
+import cyclops.monads.*;
+import cyclops.monads.FJWitness.list;
+import cyclops.monads.FJWitness.nonEmptyList;
 import cyclops.monads.FJWitness.option;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import cyclops.conversion.functionaljava.ToCyclopsReact;
-import com.aol.cyclops.functionaljava.hkt.OptionKind;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.Value;
@@ -17,16 +25,22 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
-import cyclops.monads.AnyM;
-import cyclops.monads.WitnessType;
+import cyclops.monads.Witness.*;
 import cyclops.monads.transformers.OptionalT;
 import cyclops.stream.ReactiveSeq;
+import cyclops.typeclasses.Active;
+import cyclops.typeclasses.InstanceDefinitions;
+import cyclops.typeclasses.Nested;
 import cyclops.typeclasses.Pure;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
+import cyclops.typeclasses.foldable.Unfoldable;
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+import fj.data.Either;
+import fj.data.List;
+import fj.data.NonEmptyList;
 import fj.data.Option;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
@@ -35,10 +49,13 @@
 import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.OptionalLong;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+import static com.aol.cyclops.functionaljava.hkt.OptionKind.widen;
+
 /**
  * Utility class for working with JDK Optionals
  *
@@ -581,15 +598,81 @@ public static <T> Option<T> narrow(final Option<? extends T> optional) {
         return (Option<T>) optional;
     }
 
+    public static <T> Active<option,T> allTypeclasses(Option<T> array){
+        return Active.of(widen(array), Instances.definitions());
+    }
+    public static <T,W2,R> Nested<option,W2,R> mapM(Option<T> array, Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs){
+        Option<Higher<W2, R>> e = array.map(i->fn.apply(i));
+        OptionKind<Higher<W2, R>> lk = widen(e);
+        return Nested.of(lk, Instances.definitions(), defs);
+    }
+
     /**
      * Companion class for creating Type Class instances for working with Options
-     * @author johnmcclean
      *
      */
     @UtilityClass
     public static class Instances {
 
-
+        public static InstanceDefinitions<option> definitions() {
+            return new InstanceDefinitions<option>() {
+
+                @Override
+                public <T, R> Functor<option> functor() {
+                    return Instances.functor();
+                }
+
+                @Override
+                public <T> Pure<option> unit() {
+                    return Instances.unit();
+                }
+
+                @Override
+                public <T, R> Applicative<option> applicative() {
+                    return Instances.applicative();
+                }
+
+                @Override
+                public <T, R> Monad<option> monad() {
+                    return Instances.monad();
+                }
+
+                @Override
+                public <T, R> Maybe<MonadZero<option>> monadZero() {
+                    return Maybe.just(Instances.monadZero());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<option>> monadPlus() {
+                    return Maybe.just(Instances.monadPlus());
+                }
+
+                @Override
+                public <T> Maybe<MonadPlus<option>> monadPlus(Monoid<Higher<option, T>> m) {
+                    return Maybe.just(Instances.monadPlus(m));
+                }
+
+                @Override
+                public <C2, T> Maybe<Traverse<option>> traverse() {
+                    return Maybe.just(Instances.traverse());
+                }
+
+                @Override
+                public <T> Maybe<Foldable<option>> foldable() {
+                    return Maybe.just(Instances.foldable());
+                }
+
+                @Override
+                public <T> Maybe<Comonad<option>> comonad() {
+                    return Maybe.just(Instances.comonad());
+                }
+
+                @Override
+                public <T> Maybe<Unfoldable<option>> unfoldable() {
+                    return Maybe.none();
+                }
+            };
+        }
         /**
          *
          * Transform a option, mulitplying every element by 2
@@ -748,7 +831,7 @@ public static <T,R> MonadZero<option> monadZero(){
          */
         public static <T> MonadPlus<option> monadPlus(){
             Monoid<Option<T>> mn = Monoid.of(Option.none(), (a, b) -> a.isSome() ? a : b);
-            Monoid<OptionKind<T>> m = Monoid.of(OptionKind.widen(mn.zero()), (f, g)-> OptionKind.widen(
+            Monoid<OptionKind<T>> m = Monoid.of(widen(mn.zero()), (f, g)-> widen(
                     mn.apply(OptionKind.narrow(f), OptionKind.narrow(g))));
 
             Monoid<Higher<option,T>> m2= (Monoid)m;
@@ -770,7 +853,11 @@ public static <T> MonadPlus<option> monadPlus(){
          * @param m Monoid to use for combining Options
          * @return Type class for combining Options
          */
-        public static <T> MonadPlus<option> monadPlus(Monoid<OptionKind<T>> m){
+        public static <T> MonadPlus<option> monadPlusK(Monoid<OptionKind<T>> m){
+            Monoid<Higher<option,T>> m2= (Monoid)m;
+            return General.monadPlus(monadZero(),m2);
+        }
+        public static <T> MonadPlus<option> monadPlus(Monoid<Higher<option,T>> m){
             Monoid<Higher<option,T>> m2= (Monoid)m;
             return General.monadPlus(monadZero(),m2);
         }
@@ -809,21 +896,21 @@ public static <T> Comonad<option> comonad(){
         }
 
         private <T> OptionKind<T> of(T value){
-            return OptionKind.widen(Option.some(value));
+            return widen(Option.some(value));
         }
         private static <T,R> OptionKind<R> ap(OptionKind<Function< T, R>> lt, OptionKind<T> option){
 
             Maybe<R> mb = FJ.maybe(lt.narrow()).combine(FJ.maybe(option.narrow()),
                     (a,b)->a.apply(b));
-            return OptionKind.widen(mb);
+            return widen(mb);
 
         }
         private static <T,R> Higher<option,R> flatMap(Higher<option,T> lt, Function<? super T, ? extends  Higher<option,R>> fn){
-            return OptionKind.widen(OptionKind.narrow(lt).bind(in->fn.andThen(OptionKind::narrow).apply(in)));
+            return widen(OptionKind.narrow(lt).bind(in->fn.andThen(OptionKind::narrow).apply(in)));
         }
         private static <T,R> OptionKind<R> map(OptionKind<T> lt, Function<? super T, ? extends R> fn){
 
-            return OptionKind.widen(OptionKind.narrow(lt).map(t->fn.apply(t)));
+            return widen(OptionKind.narrow(lt).map(t->fn.apply(t)));
         }
 
 
@@ -835,6 +922,150 @@ private static <C2,T,R> Higher<C2, Higher<option, R>> traverseA(Applicative<C2>
         }
 
     }
+    public static interface OptionNested {
+        public static <T> Nested<option,option,T> option(Option<Option<T>> nested){
+            Option<OptionKind<T>> f = nested.map(OptionKind::widen);
+            OptionKind<OptionKind<T>> x = widen(f);
+            OptionKind<Higher<option,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(), Options.Instances.definitions());
+        }
+        public static <L,T> Nested<option,Higher<FJWitness.either,L>,T> either(Option<Either<L,T>> nested){
+            Option<EitherKind<L,T>> f = nested.map(EitherKind::widen);
+            OptionKind<EitherKind<L,T>> x = widen(f);
+            OptionKind<Higher<Higher<FJWitness.either,L>,T>> y = (OptionKind)x;
+
+            return Nested.of(y,Instances.definitions(), Eithers.Instances.definitions());
+        }
+        public static <T> Nested<option,nonEmptyList,T> nonEmptyList(Option<NonEmptyList<T>> nested){
+            Option<NonEmptyListKind<T>> f = nested.map(NonEmptyListKind::widen);
+            OptionKind<NonEmptyListKind<T>> x = widen(f);
+            OptionKind<Higher<nonEmptyList,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),NonEmptyLists.Instances.definitions());
+        }
+        public static <T> Nested<option,FJWitness.stream,T> stream(Option<fj.data.Stream<T>> nested){
+            Option<StreamKind<T>> f = nested.map(StreamKind::widen);
+            OptionKind<StreamKind<T>> x = widen(f);
+            OptionKind<Higher<FJWitness.stream,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.companion.functionaljava.Streams.Instances.definitions());
+        }
+        public static <T> Nested<option,list,T> list(Option<List<T>> nested){
+            Option<ListKind<T>> f = nested.map(ListKind::widen);
+            OptionKind<ListKind<T>> x = widen(f);
+            OptionKind<Higher<list,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Lists.Instances.definitions());
+        }
+
+        public static <T> Nested<option,reactiveSeq,T> reactiveSeq(Option<ReactiveSeq<T>> nested){
+            OptionKind<ReactiveSeq<T>> x = widen(nested);
+            OptionKind<Higher<reactiveSeq,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<option,Witness.maybe,T> maybe(Option<Maybe<T>> nested){
+            OptionKind<Maybe<T>> x = widen(nested);
+            OptionKind<Higher<Witness.maybe,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<option,Witness.eval,T> eval(Option<Eval<T>> nested){
+            OptionKind<Eval<T>> x = widen(nested);
+            OptionKind<Higher<Witness.eval,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<option,Witness.future,T> future(Option<cyclops.async.Future<T>> nested){
+            OptionKind<cyclops.async.Future<T>> x = widen(nested);
+            OptionKind<Higher<Witness.future,T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<option,Higher<xor,S>, P> xor(Option<Xor<S, P>> nested){
+            OptionKind<Xor<S, P>> x = widen(nested);
+            OptionKind<Higher<Higher<xor,S>, P>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<option,Higher<reader,S>, T> reader(Option<Reader<S, T>> nested){
+            OptionKind<Reader<S, T>> x = widen(nested);
+            OptionKind<Higher<Higher<reader,S>, T>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<option,Higher<Witness.tryType,S>, P> cyclopsTry(Option<cyclops.control.Try<P, S>> nested){
+            OptionKind<cyclops.control.Try<P, S>> x = widen(nested);
+            OptionKind<Higher<Higher<Witness.tryType,S>, P>> y = (OptionKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<option,optional,T> javaOptional(Option<Optional<T>> nested){
+            Option<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            OptionKind<OptionalKind<T>> x = OptionKind.widen(f);
+
+            OptionKind<Higher<optional,T>> y = (OptionKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<option,completableFuture,T> javaCompletableFuture(Option<CompletableFuture<T>> nested){
+            Option<CompletableFutureKind<T>> f = nested.map(o -> CompletableFutureKind.widen(o));
+            OptionKind<CompletableFutureKind<T>> x = OptionKind.widen(f);
+            OptionKind<Higher<completableFuture,T>> y = (OptionKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<option,Witness.stream,T> javaStream(Option<java.util.stream.Stream<T>> nested){
+            Option<cyclops.companion.Streams.StreamKind<T>> f = nested.map(o -> cyclops.companion.Streams.StreamKind.widen(o));
+            OptionKind<cyclops.companion.Streams.StreamKind<T>> x = OptionKind.widen(f);
+            OptionKind<Higher<Witness.stream,T>> y = (OptionKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedOption{
+        public static <T> Nested<reactiveSeq,option,T> reactiveSeq(ReactiveSeq<Option<T>> nested){
+            ReactiveSeq<Higher<option,T>> x = nested.map(OptionKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,option,T> maybe(Maybe<Option<T>> nested){
+            Maybe<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,option,T> eval(Eval<Option<T>> nested){
+            Eval<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,option,T> future(cyclops.async.Future<Option<T>> nested){
+            cyclops.async.Future<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,option, P> xor(Xor<S, Option<P>> nested){
+            Xor<S, Higher<option,P>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,option, T> reader(Reader<S, Option<T>> nested){
+
+            Reader<S, Higher<option, T>>  x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,option, P> cyclopsTry(cyclops.control.Try<Option<P>, S> nested){
+            cyclops.control.Try<Higher<option,P>, S> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,option,T> javaOptional(Optional<Option<T>> nested){
+            Optional<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,option,T> javaCompletableFuture(CompletableFuture<Option<T>> nested){
+            CompletableFuture<Higher<option,T>> x = nested.thenApply(OptionKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,option,T> javaStream(java.util.stream.Stream<Option<T>> nested){
+            java.util.stream.Stream<Higher<option,T>> x = nested.map(OptionKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 
 
 }
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
index f69d6a10..8b5e91e2 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Streams.java
@@ -1,11 +1,21 @@
 package cyclops.companion.functionaljava;
 
+import com.aol.cyclops.functionaljava.hkt.*;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
+import cyclops.companion.Optionals;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Xor;
 import cyclops.conversion.functionaljava.FromJDK;
 import cyclops.conversion.functionaljava.FromJooqLambda;
 import cyclops.monads.FJWitness;
+import cyclops.monads.FJWitness.list;
+import cyclops.monads.FJWitness.nonEmptyList;
+import cyclops.monads.FJWitness.option;
 import cyclops.monads.FJWitness.stream;
-import com.aol.cyclops.functionaljava.hkt.StreamKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.types.anyM.AnyMSeq;
 
@@ -13,6 +23,8 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.monads.AnyM;
+import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
@@ -26,13 +38,12 @@
 import cyclops.typeclasses.monad.*;
 import fj.F;
 import fj.P2;
-import fj.data.List;
-import fj.data.Option;
-import fj.data.Stream;
+import fj.data.*;
 import lombok.experimental.UtilityClass;
 import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
@@ -651,6 +662,149 @@ public <R, T> Higher<stream, R> unfold(T b, Function<? super T, Optional<Tuple2<
         }
     }
 
+    public static interface StreamNested {
+        public static <T> Nested<stream,option,T> option(Stream<Option<T>> nested){
+            Stream<OptionKind<T>> f = nested.map(OptionKind::widen);
+            StreamKind<OptionKind<T>> x = widen(f);
+            StreamKind<Higher<option,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(), Options.Instances.definitions());
+        }
+        public static <L,T> Nested<stream,Higher<FJWitness.either,L>,T> either(Stream<Either<L,T>> nested){
+            Stream<EitherKind<L,T>> f = nested.map(EitherKind::widen);
+            StreamKind<EitherKind<L,T>> x = widen(f);
+            StreamKind<Higher<Higher<FJWitness.either,L>,T>> y = (StreamKind)x;
+
+            return Nested.of(y,Instances.definitions(), Eithers.Instances.definitions());
+        }
+        public static <T> Nested<stream,nonEmptyList,T> nonEmptyList(Stream<NonEmptyList<T>> nested){
+            Stream<NonEmptyListKind<T>> f = nested.map(NonEmptyListKind::widen);
+            StreamKind<NonEmptyListKind<T>> x = widen(f);
+            StreamKind<Higher<nonEmptyList,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),NonEmptyLists.Instances.definitions());
+        }
+        public static <T> Nested<stream,list,T> list(Stream<List<T>> nested){
+            Stream<ListKind<T>> f = nested.map(ListKind::widen);
+            StreamKind<ListKind<T>> x = widen(f);
+            StreamKind<Higher<FJWitness.list,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Lists.Instances.definitions());
+        }
+        public static <T> Nested<stream,stream,T> stream(Stream<Stream<T>> nested){
+            Stream<StreamKind<T>> f = nested.map(StreamKind::widen);
+            StreamKind<StreamKind<T>> x = widen(f);
+            StreamKind<Higher<stream,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Streams.Instances.definitions());
+        }
+
+        public static <T> Nested<stream,reactiveSeq,T> reactiveSeq(Stream<ReactiveSeq<T>> nested){
+            StreamKind<ReactiveSeq<T>> x = widen(nested);
+            StreamKind<Higher<reactiveSeq,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <T> Nested<stream,Witness.maybe,T> maybe(Stream<Maybe<T>> nested){
+            StreamKind<Maybe<T>> x = widen(nested);
+            StreamKind<Higher<Witness.maybe,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <T> Nested<stream,Witness.eval,T> eval(Stream<Eval<T>> nested){
+            StreamKind<Eval<T>> x = widen(nested);
+            StreamKind<Higher<Witness.eval,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <T> Nested<stream,Witness.future,T> future(Stream<cyclops.async.Future<T>> nested){
+            StreamKind<cyclops.async.Future<T>> x = widen(nested);
+            StreamKind<Higher<Witness.future,T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <S, P> Nested<stream,Higher<xor,S>, P> xor(Stream<Xor<S, P>> nested){
+            StreamKind<Xor<S, P>> x = widen(nested);
+            StreamKind<Higher<Higher<xor,S>, P>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <S,T> Nested<stream,Higher<reader,S>, T> reader(Stream<Reader<S, T>> nested){
+            StreamKind<Reader<S, T>> x = widen(nested);
+            StreamKind<Higher<Higher<reader,S>, T>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<stream,Higher<Witness.tryType,S>, P> cyclopsTry(Stream<cyclops.control.Try<P, S>> nested){
+            StreamKind<cyclops.control.Try<P, S>> x = widen(nested);
+            StreamKind<Higher<Higher<Witness.tryType,S>, P>> y = (StreamKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <T> Nested<stream,optional,T> javaOptional(Stream<Optional<T>> nested){
+            Stream<OptionalKind<T>> f = nested.map(o -> OptionalKind.widen(o));
+            StreamKind<OptionalKind<T>> x = StreamKind.widen(f);
 
+            StreamKind<Higher<optional,T>> y = (StreamKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <T> Nested<stream,completableFuture,T> javaCompletableFuture(Stream<CompletableFuture<T>> nested){
+            Stream<CompletableFutureKind<T>> f = nested.map(o -> CompletableFutureKind.widen(o));
+            StreamKind<CompletableFutureKind<T>> x = StreamKind.widen(f);
+            StreamKind<Higher<completableFuture,T>> y = (StreamKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <T> Nested<stream,Witness.stream,T> javaStream(Stream<java.util.stream.Stream<T>> nested){
+            Stream<cyclops.companion.Streams.StreamKind<T>> f = nested.map(o -> cyclops.companion.Streams.StreamKind.widen(o));
+            StreamKind<cyclops.companion.Streams.StreamKind<T>> x = StreamKind.widen(f);
+            StreamKind<Higher<Witness.stream,T>> y = (StreamKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedStream{
+        public static <T> Nested<reactiveSeq,stream,T> reactiveSeq(ReactiveSeq<Stream<T>> nested){
+            ReactiveSeq<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <T> Nested<maybe,stream,T> maybe(Maybe<Stream<T>> nested){
+            Maybe<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<eval,stream,T> eval(Eval<Stream<T>> nested){
+            Eval<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.future,stream,T> future(cyclops.async.Future<Stream<T>> nested){
+            cyclops.async.Future<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <S, P> Nested<Higher<xor,S>,stream, P> xor(Xor<S, Stream<P>> nested){
+            Xor<S, Higher<stream,P>> x = nested.map(StreamKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <S,T> Nested<Higher<reader,S>,stream, T> reader(Reader<S, Stream<T>> nested){
+
+            Reader<S, Higher<stream, T>>  x = nested.map(StreamKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <S extends Throwable, P> Nested<Higher<Witness.tryType,S>,stream, P> cyclopsTry(cyclops.control.Try<Stream<P>, S> nested){
+            cyclops.control.Try<Higher<stream,P>, S> x = nested.map(StreamKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<optional,stream,T> javaOptional(Optional<Stream<T>> nested){
+            Optional<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <T> Nested<completableFuture,stream,T> javaCompletableFuture(CompletableFuture<Stream<T>> nested){
+            CompletableFuture<Higher<stream,T>> x = nested.thenApply(StreamKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <T> Nested<Witness.stream,stream,T> javaStream(java.util.stream.Stream<Stream<T>> nested){
+            java.util.stream.Stream<Higher<stream,T>> x = nested.map(StreamKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
 
 }

From aa09994c39817eba8e4251cbb5b64a16c8a8745e Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 16:23:41 +0100
Subject: [PATCH 22/30] Functional Java migration

---
 .../companion/functionaljava/Eithers.java     | 180 +++++++++++++++++-
 1 file changed, 172 insertions(+), 8 deletions(-)

diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
index 84a5cf17..ef180c54 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
@@ -1,12 +1,19 @@
 package cyclops.companion.functionaljava;
 
 
-import com.aol.cyclops.functionaljava.hkt.EitherKind;
+import com.aol.cyclops.functionaljava.hkt.*;
 import com.aol.cyclops2.hkt.Higher;
 import com.aol.cyclops2.hkt.Higher2;
 import cyclops.collections.mutable.ListX;
+import cyclops.companion.CompletableFutures;
+import cyclops.companion.CompletableFutures.CompletableFutureKind;
 import cyclops.companion.Monoids;
+import cyclops.companion.Optionals;
+import cyclops.companion.Optionals.OptionalKind;
+import cyclops.control.Eval;
 import cyclops.control.Maybe;
+import cyclops.control.Reader;
+import cyclops.control.Try;
 import cyclops.control.Xor;
 import cyclops.monads.FJWitness;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
@@ -20,7 +27,11 @@
 import cyclops.function.Reducer;
 import cyclops.monads.AnyM;
 import cyclops.monads.FJWitness.either;
+import cyclops.monads.FJWitness.list;
+import cyclops.monads.FJWitness.nonEmptyList;
+import cyclops.monads.FJWitness.option;
 import cyclops.monads.Witness;
+import cyclops.monads.Witness.*;
 import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
@@ -36,13 +47,20 @@
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.monad.*;
 import fj.data.Either;
+import fj.data.List;
+import fj.data.NonEmptyList;
+import fj.data.Option;
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+import static com.aol.cyclops.functionaljava.hkt.EitherKind.widen;
+
 /**
  * Utility class for working with Eithers
  *
@@ -446,11 +464,11 @@ public static <L,T> Either<L,T> narrow(final Either<L,? extends T> eitheral) {
     }
 
     public static <L,R> Active<Higher<either,L>,R> allTypeclasses(Either<L,R> either){
-        return Active.of(EitherKind.widen(either), Eithers.Instances.definitions());
+        return Active.of(widen(either), Eithers.Instances.definitions());
     }
     public static <L,R,W2,R2> Nested<Higher<either,L>,W2,R2> mapM(Either<L,R> either,Function<? super R,? extends Higher<W2,R2>> fn, InstanceDefinitions<W2> defs){
         Either<L, Higher<W2, R2>> e = either.bimap(i -> i, i -> fn.apply(i));
-        EitherKind<L, Higher<W2, R2>> ek = EitherKind.widen(e);
+        EitherKind<L, Higher<W2, R2>> ek = widen(e);
         return Nested.of(ek, Eithers.Instances.definitions(), defs);
     }
     public <L,R,W extends WitnessType<W>> XorT<W, L, R> liftM(Either<L,R> either,W witness) {
@@ -523,7 +541,7 @@ public static <L> Functor<Higher<either, L>> functor() {
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> map(Function<? super T, ? extends R> fn, Higher<Higher<either, L>, T> ds) {
                     Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.bimap(i->i,r->fn.apply(r)));
+                    return widen(either.bimap(i->i,r->fn.apply(r)));
                 }
             };
         }
@@ -544,7 +562,7 @@ public static <L> Applicative<Higher<either, L>> applicative() {
                 public <T, R> Higher<Higher<either, L>, R> ap(Higher<Higher<either, L>, ? extends Function<T, R>> fn, Higher<Higher<either, L>, T> apply) {
                     Either<L,T>  either = EitherKind.narrowK(apply);
                     Either<L, ? extends Function<T, R>> eitherFn = EitherKind.narrowK(fn);
-                    return EitherKind.widen(Eithers.xor(ToCyclopsReact.xor(eitherFn).combine(ToCyclopsReact.xor(either),(a,b)->a.apply(b))));
+                    return widen(Eithers.xor(ToCyclopsReact.xor(eitherFn).combine(ToCyclopsReact.xor(either),(a,b)->a.apply(b))));
                 }
 
                 @Override
@@ -564,7 +582,7 @@ public static <L> Monad<Higher<either, L>> monad() {
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
                     Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
+                    return widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
                 }
 
                 @Override
@@ -646,7 +664,7 @@ public static <L> MonadZero<Higher<either, L>> monadZero() {
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
                     Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
+                    return widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
                 }
 
                 @Override
@@ -687,7 +705,7 @@ public static <L,T> MonadPlus<Higher<either, L>> monadPlus(Monoid<Higher<Higher<
                 @Override
                 public <T, R> Higher<Higher<either, L>, R> flatMap(Function<? super T, ? extends Higher<Higher<either, L>, R>> fn, Higher<Higher<either, L>, T> ds) {
                     Either<L,T> either = EitherKind.narrowK(ds);
-                    return EitherKind.widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
+                    return widen(either.right().bind(i->fn.andThen(EitherKind::narrowK).apply(i)));
                 }
 
                 @Override
@@ -731,5 +749,151 @@ public <T> Higher<Higher<either, L>, T> unit(T value) {
         }
     }
 
+    public static interface EitherNested {
+        public static <L1,L2,T> Nested<Higher<either,L1>,Higher<either,L2>,T> either(Either<L1,Either<L2,T>> nested){
+            Either<L1,EitherKind<L2,T>> f = nested.bimap(i->i,EitherKind::widen);
+            EitherKind<L1,EitherKind<L2,T>> x = widen(f);
+            EitherKind<L1,Higher<Higher<either,L2>,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(), Eithers.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,nonEmptyList,T> nonEmptyList(Either<L,NonEmptyList<T>> nested){
+            Either<L,NonEmptyListKind<T>> f = nested.bimap(i->i,NonEmptyListKind::widen);
+            EitherKind<L,NonEmptyListKind<T>> x = widen(f);
+            EitherKind<L,Higher<nonEmptyList,T>> y = (EitherKind)x;
+
+            return Nested.of(y,Instances.definitions(), NonEmptyLists.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,option,T> option(Either<L,Option<T>> nested){
+            Either<L,OptionKind<T>> f = nested.bimap(i->i,OptionKind::widen);
+            EitherKind<L,OptionKind<T>> x = widen(f);
+            EitherKind<L,Higher<option,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),Options.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,FJWitness.stream,T> stream(Either<L,fj.data.Stream<T>> nested){
+            Either<L,StreamKind<T>> f = nested.bimap(i->i,StreamKind::widen);
+            EitherKind<L,StreamKind<T>> x = widen(f);
+            EitherKind<L,Higher<FJWitness.stream,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.companion.functionaljava.Streams.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,list,T> list(Either<L,List<T>> nested){
+            Either<L,ListKind<T>> f = nested.bimap(i->i,ListKind::widen);
+            EitherKind<L,ListKind<T>> x = widen(f);
+            EitherKind<L,Higher<list,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),Lists.Instances.definitions());
+        }
+
+        public static <L,T> Nested<Higher<either,L>,reactiveSeq,T> reactiveSeq(Either<L,ReactiveSeq<T>> nested){
+            EitherKind<L,ReactiveSeq<T>> x = widen(nested);
+            EitherKind<L,Higher<reactiveSeq,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),ReactiveSeq.Instances.definitions());
+        }
+
+        public static <L,T> Nested<Higher<either,L>,Witness.maybe,T> maybe(Either<L,Maybe<T>> nested){
+            EitherKind<L,Maybe<T>> x = widen(nested);
+            EitherKind<L,Higher<Witness.maybe,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),Maybe.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,Witness.eval,T> eval(Either<L,Eval<T>> nested){
+            EitherKind<L,Eval<T>> x = widen(nested);
+            EitherKind<L,Higher<Witness.eval,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),Eval.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,Witness.future,T> future(Either<L,cyclops.async.Future<T>> nested){
+            EitherKind<L,cyclops.async.Future<T>> x = widen(nested);
+            EitherKind<L,Higher<Witness.future,T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.async.Future.Instances.definitions());
+        }
+        public static <L,S, P> Nested<Higher<either,L>,Higher<xor,S>, P> xor(Either<L,Xor<S, P>> nested){
+            EitherKind<L,Xor<S, P>> x = widen(nested);
+            EitherKind<L,Higher<Higher<xor,S>, P>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),Xor.Instances.definitions());
+        }
+        public static <L,S,T> Nested<Higher<either,L>,Higher<reader,S>, T> reader(Either<L,Reader<S, T>> nested){
+            EitherKind<L,Reader<S, T>> x = widen(nested);
+            EitherKind<L,Higher<Higher<reader,S>, T>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),Reader.Instances.definitions());
+        }
+        public static <L,S extends Throwable, P> Nested<Higher<either,L>,Higher<tryType,S>, P> cyclopsTry(Either<L,Try<P, S>> nested){
+            EitherKind<L,Try<P, S>> x = widen(nested);
+            EitherKind<L,Higher<Higher<tryType,S>, P>> y = (EitherKind)x;
+            return Nested.of(y,Instances.definitions(),cyclops.control.Try.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,optional,T> javaOptional(Either<L,Optional<T>> nested){
+            Either<L,OptionalKind<T>> f = nested.bimap(i->i,o -> OptionalKind.widen(o));
+            EitherKind<L,OptionalKind<T>> x = widen(f);
+
+            EitherKind<L,Higher<optional,T>> y = (EitherKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Optionals.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,completableFuture,T> javaCompletableFuture(Either<L,CompletableFuture<T>> nested){
+            Either<L,CompletableFutureKind<T>> f = nested.bimap(i->i,o -> CompletableFutureKind.widen(o));
+            EitherKind<L,CompletableFutureKind<T>> x = widen(f);
+            EitherKind<L,Higher<completableFuture,T>> y = (EitherKind)x;
+            return Nested.of(y, Instances.definitions(), CompletableFutures.Instances.definitions());
+        }
+        public static <L,T> Nested<Higher<either,L>,Witness.stream,T> javaStream(Either<L,java.util.stream.Stream<T>> nested){
+            Either<L,cyclops.companion.Streams.StreamKind<T>> f = nested.bimap(i->i,o -> cyclops.companion.Streams.StreamKind.widen(o));
+            EitherKind<L,cyclops.companion.Streams.StreamKind<T>> x = widen(f);
+            EitherKind<L,Higher<Witness.stream,T>> y = (EitherKind)x;
+            return Nested.of(y, Instances.definitions(), cyclops.companion.Streams.Instances.definitions());
+        }
+
+    }
+
+    public static interface NestedEither{
+        public static <L,T> Nested<reactiveSeq,Higher<either,L>,T> reactiveSeq(ReactiveSeq<Either<L,T>> nested){
+            ReactiveSeq<Higher<Higher<either,L>,T>> x = nested.map(EitherKind::widenK);
+            return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
+        }
+
+        public static <L,T> Nested<maybe,Higher<either,L>,T> maybe(Maybe<Either<L,T>> nested){
+            Maybe<Higher<Higher<either,L>,T>> x = nested.map(EitherKind::widenK);
+
+            return Nested.of(x,Maybe.Instances.definitions(),Instances.definitions());
+        }
+        public static <L,T> Nested<eval,Higher<either,L>,T> eval(Eval<Either<L,T>> nested){
+            Eval<Higher<Higher<either,L>,T>> x = nested.map(EitherKind::widenK);
+
+            return Nested.of(x,Eval.Instances.definitions(),Instances.definitions());
+        }
+        public static <L,T> Nested<Witness.future,Higher<either,L>,T> future(cyclops.async.Future<Either<L,T>> nested){
+            cyclops.async.Future<Higher<Higher<either,L>,T>> x = nested.map(EitherKind::widenK);
+
+            return Nested.of(x,cyclops.async.Future.Instances.definitions(),Instances.definitions());
+        }
+        public static <L,S, P> Nested<Higher<xor,S>,Higher<either,L>, P> xor(Xor<S, Either<L,P>> nested){
+            Xor<S, Higher<Higher<either,L>,P>> x = nested.map(EitherKind::widenK);
+
+            return Nested.of(x,Xor.Instances.definitions(),Instances.definitions());
+        }
+        public static <L,S,T> Nested<Higher<reader,S>,Higher<either,L>, T> reader(Reader<S, Either<L,T>> nested){
+
+            Reader<S, Higher<Higher<either,L>, T>>  x = nested.map(EitherKind::widenK);
+
+            return Nested.of(x,Reader.Instances.definitions(),Instances.definitions());
+        }
+        public static <L,S extends Throwable, P> Nested<Higher<tryType,S>,Higher<either,L>, P> cyclopsTry(Try<Either<L,P>, S> nested){
+            cyclops.control.Try<Higher<Higher<either,L>,P>, S> x = nested.map(EitherKind::widenK);
+
+            return Nested.of(x,cyclops.control.Try.Instances.definitions(),Instances.definitions());
+        }
+        public static <L,T> Nested<optional,Higher<either,L>,T> javaEitheral(Optional<Either<L,T>> nested){
+            Optional<Higher<Higher<either,L>,T>> x = nested.map(EitherKind::widenK);
+
+            return  Nested.of(OptionalKind.widen(x), cyclops.companion.Optionals.Instances.definitions(), Instances.definitions());
+        }
+        public static <L,T> Nested<completableFuture,Higher<either,L>,T> javaCompletableFuture(CompletableFuture<Either<L,T>> nested){
+            CompletableFuture<Higher<Higher<either,L>,T>> x = nested.thenApply(EitherKind::widenK);
+
+            return Nested.of(CompletableFutureKind.widen(x), CompletableFutures.Instances.definitions(),Instances.definitions());
+        }
+        public static <L,T> Nested<Witness.stream,Higher<either,L>,T> javaStream(java.util.stream.Stream<Either<L,T>> nested){
+            java.util.stream.Stream<Higher<Higher<either,L>,T>> x = nested.map(EitherKind::widenK);
+
+            return Nested.of(cyclops.companion.Streams.StreamKind.widen(x), cyclops.companion.Streams.Instances.definitions(),Instances.definitions());
+        }
+    }
+
+
 
 }

From b57573eac785b10d72cc8a65030d33b1e45c30cb Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 17:04:50 +0100
Subject: [PATCH 23/30] bump versions

---
 .../hkt/typeclasses/instances/MonosTest.java  |  2 +-
 cyclops-rxjava2/build.gradle                  |  2 +-
 .../hkt/typeclesses/instances/NestedTest.java | 48 +++++++++++++++++++
 gradle.properties                             |  8 ++--
 4 files changed, 54 insertions(+), 6 deletions(-)
 create mode 100644 cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java

diff --git a/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java b/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java
index a94467d2..3d22d9c4 100644
--- a/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java
+++ b/cyclops-reactor/src/test/java/com/aol/cyclops/reactor/hkt/typeclasses/instances/MonosTest.java
@@ -116,7 +116,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<MonoKind<Integer>> m = Monoid.of(MonoKind.widen(Mono.empty()), (a, b)->a.toFuture().isDone() ? b : a);
-        MonoKind<Integer> opt = Instances.<Integer>monadPlus(m)
+        MonoKind<Integer> opt = Instances.<Integer>monadPlusK(m)
                                       .plus(MonoKind.widen(Mono.just(5)), MonoKind.widen(Mono.just(10)))
                                       .convert(MonoKind::narrowK);
         assertThat(opt.block(),equalTo(10));
diff --git a/cyclops-rxjava2/build.gradle b/cyclops-rxjava2/build.gradle
index 0def6ef5..324f1965 100644
--- a/cyclops-rxjava2/build.gradle
+++ b/cyclops-rxjava2/build.gradle
@@ -32,7 +32,7 @@ configurations {
 dependencies {
 
 
-	compile group: 'io.reactivex.rxjava2', name: 'rxjava', version: '2.1.0'
+	compile group: 'io.reactivex.rxjava2', name: 'rxjava', version: '2.1.1'
 	compile group: 'com.aol.simplereact', name:'cyclops-react', version:cyclopsReactVersion
 	provided group: 'org.projectlombok', name: 'lombok', version:lombokVersion
 
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java
new file mode 100644
index 00000000..c0789472
--- /dev/null
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java
@@ -0,0 +1,48 @@
+package com.aol.cyclops.vavr.hkt.typeclesses.instances;
+
+import com.aol.cyclops.vavr.hkt.ListKind;
+import com.aol.cyclops.vavr.hkt.StreamKind;
+import com.aol.cyclops2.hkt.Higher;
+import com.google.common.collect.FluentIterable;
+import cyclops.companion.Monoids;
+import cyclops.companion.vavr.Lists;
+import cyclops.companion.vavr.Streams;
+import cyclops.companion.vavr.Streams.StreamNested;
+import cyclops.monads.VavrWitness;
+import cyclops.monads.VavrWitness.list;
+
+import cyclops.monads.VavrWitness.stream;
+import io.vavr.collection.List;
+import io.vavr.collection.Stream;
+import io.vavr.control.Either;
+import io.vavr.control.Option;
+import org.junit.Test;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+
+public class NestedTest {
+
+    @Test
+    public void listOption(){
+        Higher<list, Integer> res = Lists.ListNested
+                                         .option(List.of(Option.some(1)))
+                                         .map(i -> i * 20)
+                                         .foldsUnsafe()
+                                         .foldLeft(Monoids.intMax);
+        List<Integer> fi = ListKind.narrow(res);
+        assertThat(fi.get(0),equalTo(20));
+    }
+    @Test
+    public void streamEither(){
+        Higher<stream, Integer> res = StreamNested.either(Stream.of(Either.right(1)))
+                                                  .map(i -> i * 20)
+                                                  .foldsUnsafe()
+                                                  .foldLeft(Monoids.intMax);
+        Stream<Integer> fi = StreamKind.narrow(res);
+        assertThat(fi.get(0),equalTo(20));
+    }
+
+}
+
diff --git a/gradle.properties b/gradle.properties
index 6299bfbe..ce5e06e7 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,14 +1,14 @@
-version=9.0.0-MI5
+version=9.0.0-MI6
 lombokVersion=1.16.2
 cyclopsReactVersion=2.0.0-FINAL
 vavrVersion=0.9.0
 guavaVersion=22.0
-functionalJavaVersion=4.5
+functionalJavaVersion=4.7
 reactiveStreamsVersion=1.0.0
 hamcrestVersion=1.3
 reactorVersion=3.0.2.RELEASE
 derive4jHKTVersion=0.9.1
-rxJavaVersion=1.1.3
+rxJavaVersion=1.3.0
 dexxVersion=0.6
-scalaVersion=2.12.0
+scalaVersion=2.12.2
 clojureVersion=1.8.0

From a3517530cb254671686c1eb2d0c43d6bccb1b173 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 17:25:56 +0100
Subject: [PATCH 24/30] documentation

---
 .../functionaljava/hkt/EitherKind.java        |  4 +-
 cyclops-vavr/readme.md                        | 60 ++++++++++++++++++-
 .../java/cyclops/companion/vavr/Options.java  |  4 +-
 .../hkt/typeclesses/instances/NestedTest.java | 19 +++++-
 4 files changed, 79 insertions(+), 8 deletions(-)

diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
index 3a25dce9..fdf862e5 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/EitherKind.java
@@ -59,11 +59,11 @@ public <W extends WitnessType<W>> XorT<W, L,R> liftM(W witness) {
         return XorT.of(witness.adapter().unit(ToCyclopsReact.xor(boxed)));
     }
 
-    public Either<L, R>.LeftProjection<L, R> left() {
+    public Either.LeftProjection<L, R> left() {
         return boxed.left();
     }
 
-    public Either<L, R>.RightProjection<L, R> right() {
+    public Either.RightProjection<L, R> right() {
         return boxed.right();
     }
 
diff --git a/cyclops-vavr/readme.md b/cyclops-vavr/readme.md
index 256584ee..03cc56a3 100644
--- a/cyclops-vavr/readme.md
+++ b/cyclops-vavr/readme.md
@@ -195,8 +195,30 @@ System.out.println(vec);
 
 # Higher Kinded Typeclasses
 
-If you really want / or need to program at a much higher level of abstraction cyclops-vavr provided psuedo Higher Kinded encordings and typeclasses for Vavr types
+cyclops provides the following Typeclasses and implementations for many Vavr Types
 
+* Unit / pure
+* Functor
+* Applicative
+* Monad
+* MonadZero
+* MonadPlus
+* Comonad
+* Foldable
+* Unfoldable
+* Eq
+* Traverse
+
+Instances are provided for the following Vavr types : Stream, List, Vector, Array, Queue, HashSet, Option, Try, Future, Either
+
+Type class instances are accessible through the Companion Object for each type.
+
+
+## Using Typeclasses
+
+### Directly 
+
+Typeclasses can be used directly (although this results in verbose and somewhat cumbersome code)
 e.g. using the Pure and Functor typeclasses for Vavr Streams
 
 ```java
@@ -204,15 +226,47 @@ e.g. using the Pure and Functor typeclasses for Vavr Streams
    Pure<stream> pure = Streams.Instances.unit();
    Functor<stream> functor = Streams.Instances.functor();
         
-   StreamKind<Integer> list = pure.unit("hello")
-                                  .apply(h->functor.map((String v) ->v.length(), h))
+   StreamKind<Integer> stream = pure.unit("hello")
+                                  .applyHKT(h->functor.map((String v) ->v.length(), h))
                                   .convert(StreamKind::narrowK);
 
         
    assertThat(list.toJavaList(),equalTo(Arrays.asList("hello".length())));
 ```
 
+### Via Active
+
+The Active class represents a Higher Kinded encoding of a Vavr (or cyclops-react/ JDK/ reactor / rx etc) type *and* it's associated type classes
+
+The code above which creates a new Stream containing a single element "hello" and transforms it to Stream of Integers (the length of each word), can be written much more succintly with Active
+```java
+Active<stream,Integer> active = Streams.allTypeClasses(Stream.empty());
+
+Active<stream,Integer> hello = active.unit("hello")
+                                     .map(String::length);
+
+Stream<Integer> stream = StreamKind.narrow(hello.getActive());
+
+```
+
+### Via Nested
+
+The Nested class represents a Nested data structure, for example a List of Options *and* the associated typeclass instances for both types.
+
+```java
+import cyclops.companion.vavr.Options.OptionNested;
 
+Nested<option,list,Integer> optList  = OptionNested.list(Option.some(List.ofAll(1,10,2,3)))
+                                                                       .map(i -> i * 20);
+
+Option<Integer> opt  = optList.foldsUnsafe()
+                              .foldLeft(Monoids.intMax)
+                              .convert(OptionKind::narrowK);
+
+
+//[200]
+
+```
 
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
index 5f4539ac..7fc93bca 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
@@ -925,7 +925,7 @@ private static <C2,T,R> Higher<C2, Higher<option, R>> traverseA(Applicative<C2>
         }
 
     }
-    public static interface OptionNest{
+    public static interface OptionNested{
 
 
         public static <T> Nested<option,lazy,T> lazy(Option<Lazy<T>> type){
@@ -1016,7 +1016,7 @@ public static <T> Nested<option,Witness.stream,T> javaStream(Option<java.util.st
 
 
     }
-    public static interface OptionNested{
+    public static interface NestedOption{
         public static <T> Nested<reactiveSeq,option,T> reactiveSeq(ReactiveSeq<Option<T>> nested){
             ReactiveSeq<Higher<option,T>> x = nested.map(OptionKind::widenK);
             return Nested.of(x,ReactiveSeq.Instances.definitions(),Instances.definitions());
diff --git a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java
index c0789472..44c1b3cd 100644
--- a/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java
+++ b/cyclops-vavr/src/test/java/com/aol/cyclops/vavr/hkt/typeclesses/instances/NestedTest.java
@@ -1,17 +1,23 @@
 package com.aol.cyclops.vavr.hkt.typeclesses.instances;
 
 import com.aol.cyclops.vavr.hkt.ListKind;
+import com.aol.cyclops.vavr.hkt.OptionKind;
 import com.aol.cyclops.vavr.hkt.StreamKind;
 import com.aol.cyclops2.hkt.Higher;
 import com.google.common.collect.FluentIterable;
 import cyclops.companion.Monoids;
 import cyclops.companion.vavr.Lists;
+import cyclops.companion.vavr.Lists.ListNested;
+import cyclops.companion.vavr.Options;
+import cyclops.companion.vavr.Options.OptionNested;
 import cyclops.companion.vavr.Streams;
 import cyclops.companion.vavr.Streams.StreamNested;
 import cyclops.monads.VavrWitness;
 import cyclops.monads.VavrWitness.list;
 
+import cyclops.monads.VavrWitness.option;
 import cyclops.monads.VavrWitness.stream;
+import cyclops.typeclasses.Nested;
 import io.vavr.collection.List;
 import io.vavr.collection.Stream;
 import io.vavr.control.Either;
@@ -26,7 +32,7 @@ public class NestedTest {
 
     @Test
     public void listOption(){
-        Higher<list, Integer> res = Lists.ListNested
+        Higher<list, Integer> res = ListNested
                                          .option(List.of(Option.some(1)))
                                          .map(i -> i * 20)
                                          .foldsUnsafe()
@@ -44,5 +50,16 @@ public void streamEither(){
         assertThat(fi.get(0),equalTo(20));
     }
 
+    @Test
+    public void optionList(){
+        Nested<option,list,Integer> optList  = OptionNested.list(Option.some(List.ofAll(1,10,2,3)))
+                                                                       .map(i -> i * 20);
+
+        Option<Integer> opt  = optList.foldsUnsafe()
+                                      .foldLeft(Monoids.intMax)
+                                      .convert(OptionKind::narrowK);
+
+        assertThat(opt,equalTo(Option.some(200)));
+    }
 }
 

From e03456b45fd84aa56785407122c723c90ddcd4d1 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 17:32:46 +0100
Subject: [PATCH 25/30] fix compile errors

---
 .../cyclops/functionaljava/hkt/ListKind.java  | 227 +++++++++++++++---
 .../collections/scala/ScalaQueueX.java        |   2 +-
 cyclops-vavr/readme.md                        |   2 +
 3 files changed, 196 insertions(+), 35 deletions(-)

diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
index 14f1f7cf..12b94493 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/hkt/ListKind.java
@@ -1,7 +1,10 @@
 package com.aol.cyclops.functionaljava.hkt;
 
+import java.lang.Class;
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.Spliterator;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 
@@ -15,16 +18,7 @@
 import cyclops.typeclasses.Active;
 import cyclops.typeclasses.InstanceDefinitions;
 import cyclops.typeclasses.Nested;
-import fj.Equal;
-import fj.F;
-import fj.F0;
-import fj.F2;
-import fj.Monoid;
-import fj.Ord;
-import fj.Ordering;
-import fj.P1;
-import fj.P2;
-import fj.Unit;
+import fj.*;
 import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.data.Array;
@@ -121,6 +115,193 @@ public static <T> List<T> narrow(final Higher<list, T> list) {
     }
 
 
+    public Array<T> toArray(Class<T[]> c) {
+        return boxed.toArray(c);
+    }
+
+    public T[] array(Class<T[]> c) {
+        return boxed.array(c);
+    }
+
+    public static <A, B, C> F<List<A>, F<List<B>, List<C>>> liftM2(F<A, F<B, C>> f) {
+        return List.liftM2(f);
+    }
+
+    public <E, B> Validation<E, List<B>> traverseValidation(Semigroup<E> s, F<T, Validation<E, B>> f) {
+        return boxed.traverseValidation(s, f);
+    }
+
+    public static <A, B, C> F<List<A>, F<List<B>, F<F<A, F<B, C>>, List<C>>>> zipWith() {
+        return List.zipWith();
+    }
+
+    public static <A, B> F<List<A>, F<List<B>, List<P2<A, B>>>> zip() {
+        return List.zip();
+    }
+
+    public static <A> F<List<A>, A> head_() {
+        return List.head_();
+    }
+
+    public static <A> F<List<A>, List<A>> tail_() {
+        return List.tail_();
+    }
+
+    public static <A> F<List<A>, Integer> length_() {
+        return List.length_();
+    }
+
+    public Option<T> maximumOption(Ord<T> o) {
+        return boxed.maximumOption(o);
+    }
+
+    public Option<T> minimumOption(Ord<T> o) {
+        return boxed.minimumOption(o);
+    }
+
+    @SafeVarargs
+    public static <A> List<A> arrayList(A... as) {
+        return List.arrayList(as);
+    }
+
+    @Deprecated
+    public static <A> List<A> list(Iterable<A> i) {
+        return List.list(i);
+    }
+
+    @Deprecated
+    public static <A> List<A> list(Iterator<A> it) {
+        return List.list(it);
+    }
+
+    public static <A> List<A> fromIterator(Iterator<A> it) {
+        return List.fromIterator(it);
+    }
+
+    public static <A> List<A> nil() {
+        return List.nil();
+    }
+
+    public static <A> F<A, F<List<A>, List<A>>> cons() {
+        return List.cons();
+    }
+
+    public static <A> F2<A, List<A>, List<A>> cons_() {
+        return List.cons_();
+    }
+
+    public static <A> F<A, List<A>> cons(List<A> tail) {
+        return List.cons(tail);
+    }
+
+    public static <A> F<List<A>, List<A>> cons_(A a) {
+        return List.cons_(a);
+    }
+
+    public static <A> List<A> cons(A head, List<A> tail) {
+        return List.cons(head, tail);
+    }
+
+    public static <A> F<List<A>, Boolean> isEmpty_() {
+        return List.isEmpty_();
+    }
+
+    public static <A> F<List<A>, Boolean> isNotEmpty_() {
+        return List.isNotEmpty_();
+    }
+
+    public static <A> List<A> join(List<List<A>> o) {
+        return List.join(o);
+    }
+
+    public static <A> F<List<List<A>>, List<A>> join() {
+        return List.join();
+    }
+
+    public static <A, B> List<A> unfold(F<B, Option<P2<A, B>>> f, B b) {
+        return List.unfold(f, b);
+    }
+
+    public static <A, B> P2<List<A>, List<B>> unzip(List<P2<A, B>> xs) {
+        return List.unzip(xs);
+    }
+
+    public static <A> List<A> replicate(int n, A a) {
+        return List.replicate(n, a);
+    }
+
+    public static List<Integer> range(int from, int to) {
+        return List.range(from, to);
+    }
+
+    public static List<Character> fromString(String s) {
+        return List.fromString(s);
+    }
+
+    public static F<String, List<Character>> fromString() {
+        return List.fromString();
+    }
+
+    public static String asString(List<Character> cs) {
+        return List.asString(cs);
+    }
+
+    public static F<List<Character>, String> asString() {
+        return List.asString();
+    }
+
+    public static <A> List<A> single(A a) {
+        return List.single(a);
+    }
+
+    public static <A> List<A> iterateWhile(F<A, A> f, F<A, Boolean> p, A a) {
+        return List.iterateWhile(f, p, a);
+    }
+
+    public static <A, B> Option<B> lookup(Equal<A> e, List<P2<A, B>> x, A a) {
+        return List.lookup(e, x, a);
+    }
+
+    public static <A, B> F2<List<P2<A, B>>, A, Option<B>> lookup(Equal<A> e) {
+        return List.lookup(e);
+    }
+
+    public static <A, B> F<F<A, List<B>>, F<List<A>, List<B>>> bind_() {
+        return List.bind_();
+    }
+
+    public static <A, B> F<F<A, B>, F<List<A>, List<B>>> map_() {
+        return List.map_();
+    }
+
+    public static <A, B> F<B, List<A>> sequence_(List<F<B, A>> fs) {
+        return List.sequence_(fs);
+    }
+
+    public static <A, B> F<F<B, F<A, B>>, F<B, F<List<A>, B>>> foldLeft() {
+        return List.foldLeft();
+    }
+
+    public static <A> F<Integer, F<List<A>, List<A>>> take() {
+        return List.take();
+    }
+
+    public static <A> List<A> iterableList(Iterable<A> i) {
+        return List.iterableList(i);
+    }
+
+    public static <A> List<A> iteratorList(Iterator<A> it) {
+        return List.iteratorList(it);
+    }
+
+    public void forEach(Consumer<? super T> action) {
+        boxed.forEach(action);
+    }
+
+    public Spliterator<T> spliterator() {
+        return boxed.spliterator();
+    }
+
     private final List<T> boxed;
 
     /**
@@ -259,22 +440,7 @@ public final Object[] toArrayObject() {
     public final T[] toJavaArray() {
         return boxed.toJavaArray();
     }
-    /**
-     * @param c
-     * @return
-     * @see fj.data.List#toArray(java.lang.Class)
-     */
-    public final Array<T> toArray(Class<T[]> c) {
-        return boxed.toArray(c);
-    }
-    /**
-     * @param c
-     * @return
-     * @see fj.data.List#array(java.lang.Class)
-     */
-    public final T[] array(Class<T[]> c) {
-        return boxed.array(c);
-    }
+
     /**
      * @param a
      * @return
@@ -564,14 +730,7 @@ public <B> Promise<List<B>> traversePromise(F<T, Promise<B>> f) {
     public <B> List<List<B>> traverseList(F<T, List<B>> f) {
         return boxed.traverseList(f);
     }
-    /**
-     * @param f
-     * @return
-     * @see fj.data.List#traverseValidation(fj.F)
-     */
-    public <E, B> Validation<E, List<B>> traverseValidation(F<T, Validation<E, B>> f) {
-        return boxed.traverseValidation(f);
-    }
+
     /**
      * @param f
      * @return
diff --git a/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaQueueX.java b/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaQueueX.java
index 0ecb0427..f941b0d5 100644
--- a/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaQueueX.java
+++ b/cyclops-scala/src/main/java/cyclops/collections/scala/ScalaQueueX.java
@@ -232,7 +232,7 @@ public ScalaQueueX<T> plusAll(Collection<? extends T> l) {
            
             Queue<T> toUse = ((ScalaQueueX)l).queue;
            
-            vec = (Queue<T>)vec.$plus$plus(toUse, (CanBuildFrom) builder);
+            vec = (Queue<T>)vec.$plus$plus(toUse, builder2);
         }
         else {
   
diff --git a/cyclops-vavr/readme.md b/cyclops-vavr/readme.md
index 03cc56a3..e164ab6f 100644
--- a/cyclops-vavr/readme.md
+++ b/cyclops-vavr/readme.md
@@ -239,7 +239,9 @@ e.g. using the Pure and Functor typeclasses for Vavr Streams
 The Active class represents a Higher Kinded encoding of a Vavr (or cyclops-react/ JDK/ reactor / rx etc) type *and* it's associated type classes
 
 The code above which creates a new Stream containing a single element "hello" and transforms it to Stream of Integers (the length of each word), can be written much more succintly with Active
+
 ```java
+
 Active<stream,Integer> active = Streams.allTypeClasses(Stream.empty());
 
 Active<stream,Integer> hello = active.unit("hello")

From 012c7c451bb3a129fa628527d92f43f83356d69d Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 17:38:32 +0100
Subject: [PATCH 26/30] fix compile

---
 cyclops-functionaljava/readme.md                         | 2 +-
 .../hkt/typeclesses/instances/ListsTest.java             | 2 +-
 .../hkt/typeclesses/instances/OptionTest.java            | 2 +-
 .../main/java/com/aol/cyclops/rx/hkt/ObservableKind.java | 9 +--------
 .../cyclops/rx/hkt/typeclasses/instances/MaybesTest.java | 2 +-
 .../rx/hkt/typeclasses/instances/SinglesTest.java        | 2 +-
 gradle.properties                                        | 2 +-
 7 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/cyclops-functionaljava/readme.md b/cyclops-functionaljava/readme.md
index f80d63a1..b1ea055c 100644
--- a/cyclops-functionaljava/readme.md
+++ b/cyclops-functionaljava/readme.md
@@ -1,6 +1,6 @@
 # Functional Java Integration
 
-v8.0.0 of cyclops-functionaljava and above is built using v4.5 of FunctionalJava.
+
 
 ## Get cyclops-functionaljava
 
diff --git a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java
index 79b05497..78513e33 100644
--- a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java
+++ b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/ListsTest.java
@@ -115,7 +115,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<ListKind<Integer>> m = Monoid.of(ListKind.widen(List.list()), (a, b)->a.isEmpty() ? b : a);
-        ListKind<Integer> list = Lists.Instances.<Integer>monadPlus(m)
+        ListKind<Integer> list = Lists.Instances.<Integer>monadPlusK(m)
                                       .plus(ListKind.widen(List.list(5)), ListKind.widen(List.list(10)))
                                       .convert(ListKind::narrowK);
         assertThat(list,equalTo(List.list(5)));
diff --git a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java
index 659b7ef3..f69d9d99 100644
--- a/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java
+++ b/cyclops-functionaljava/src/test/java/com/aol/cyclops/functionaljava/hkt/typeclesses/instances/OptionTest.java
@@ -108,7 +108,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<OptionKind<Integer>> m = Monoid.of(OptionKind.widen(Option.none()), (a, b)->a.isSome() ? b : a);
-        OptionKind<Integer> opt = Options.Instances.<Integer>monadPlus(m)
+        OptionKind<Integer> opt = Options.Instances.<Integer>monadPlusK(m)
                                       .plus(OptionKind.widen(Option.some(5)), OptionKind.widen(Option.some(10)))
                                       .convert(OptionKind::narrowK);
         assertThat(opt,equalTo(Option.some(10)));
diff --git a/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java b/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
index bc9724d4..0dc09fee 100644
--- a/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
+++ b/cyclops-rx/src/main/java/com/aol/cyclops/rx/hkt/ObservableKind.java
@@ -189,14 +189,7 @@ public boolean equals(Object obj) {
         return boxed.equals(obj);
     }
 
-    /**
-     * @param conversion
-     * @return
-     * @see rx.Observable#extend(rx.functions.Func1)
-     */
-    public <R> R extend(Func1<? super OnSubscribe<T>, ? extends R> conversion) {
-        return boxed.extend(conversion);
-    }
+
 
     /**
      * @return
diff --git a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java
index 6ef2f915..b42de488 100644
--- a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java
+++ b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/MaybesTest.java
@@ -111,7 +111,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<MaybeKind<Integer>> m = Monoid.of(widen(Maybe.never()), (a, b)->a.toFuture().isDone() ? b : a);
-        MaybeKind<Integer> opt = Instances.<Integer>monadPlus(m)
+        MaybeKind<Integer> opt = Instances.<Integer>monadPlusK(m)
                                       .plus(widen(Maybe.just(5)), widen(Maybe.just(10)))
                                       .convert(MaybeKind::narrowK);
         assertThat(opt.blockingGet(),equalTo(10));
diff --git a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java
index d5e5dd47..b29af528 100644
--- a/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java
+++ b/cyclops-rxjava2/src/test/java/com/aol/cyclops/rx/hkt/typeclasses/instances/SinglesTest.java
@@ -126,7 +126,7 @@ public void monadPlus(){
     public void monadPlusNonEmpty(){
         
         Monoid<SingleKind<Integer>> m = Monoid.of(widen(Single.never()), (a, b)->a.toFuture().isDone() ? b : a);
-        SingleKind<Integer> opt = Instances.<Integer>monadPlus(m)
+        SingleKind<Integer> opt = Instances.<Integer>monadPlusK(m)
                                       .plus(widen(Single.just(5)), widen(Single.just(10)))
                                       .convert(SingleKind::narrowK);
         assertThat(opt.blockingGet(),equalTo(10));
diff --git a/gradle.properties b/gradle.properties
index ce5e06e7..0f5423af 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -6,7 +6,7 @@ guavaVersion=22.0
 functionalJavaVersion=4.7
 reactiveStreamsVersion=1.0.0
 hamcrestVersion=1.3
-reactorVersion=3.0.2.RELEASE
+reactorVersion=3.0.7.RELEASE
 derive4jHKTVersion=0.9.1
 rxJavaVersion=1.3.0
 dexxVersion=0.6

From 30addfa790091228bde1dd1fb15f8eb1721be52c Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 18:08:17 +0100
Subject: [PATCH 27/30] fix errors'

---
 .../aol/cyclops/functionaljava/adapter/ValidationAdapter.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java
index 57d6611f..f9b2ed7a 100644
--- a/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java
+++ b/cyclops-functionaljava/src/main/java/com/aol/cyclops/functionaljava/adapter/ValidationAdapter.java
@@ -72,6 +72,6 @@ public <T> AnyM<validation, T> unit(T o) {
 
     @Override
     public <T, R> AnyM<validation, R> map(AnyM<validation, T> t, Function<? super T, ? extends R> fn) {
-        return FJ.validation(validation(t)).map(x->fn.apply(x));
+        return FJ.validation(validation(t).map(x->fn.apply(x)));
     }
 }

From 5a879f338cce35a7730b21774b994b2bf1728b2d Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 18:26:32 +0100
Subject: [PATCH 28/30] coproduct factories

---
 .../companion/functionaljava/Eithers.java     | 29 +++++++++++++------
 .../companion/functionaljava/Options.java     | 15 +++++++---
 .../cyclops/companion/guava/Optionals.java    | 19 ++++++++++--
 cyclops-vavr/readme.md                        | 17 +++++++++++
 .../java/cyclops/companion/vavr/Arrays.java   |  3 ++
 .../java/cyclops/companion/vavr/Eithers.java  | 12 ++++++++
 .../java/cyclops/companion/vavr/HashSets.java |  6 ++++
 .../java/cyclops/companion/vavr/Lazys.java    |  4 +++
 .../java/cyclops/companion/vavr/Lists.java    |  6 ++++
 .../java/cyclops/companion/vavr/Options.java  | 12 ++++++++
 10 files changed, 107 insertions(+), 16 deletions(-)

diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
index ef180c54..066daa5f 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
@@ -15,7 +15,7 @@
 import cyclops.control.Reader;
 import cyclops.control.Try;
 import cyclops.control.Xor;
-import cyclops.monads.FJWitness;
+import cyclops.monads.*;
 import cyclops.conversion.functionaljava.FromCyclopsReact;
 import cyclops.conversion.functionaljava.ToCyclopsReact;
 import com.aol.cyclops2.data.collections.extensions.CollectionX;
@@ -25,21 +25,15 @@
 import cyclops.function.Fn4;
 import cyclops.function.Monoid;
 import cyclops.function.Reducer;
-import cyclops.monads.AnyM;
 import cyclops.monads.FJWitness.either;
 import cyclops.monads.FJWitness.list;
 import cyclops.monads.FJWitness.nonEmptyList;
 import cyclops.monads.FJWitness.option;
-import cyclops.monads.Witness;
 import cyclops.monads.Witness.*;
-import cyclops.monads.WitnessType;
 import cyclops.monads.transformers.XorT;
 import cyclops.stream.ReactiveSeq;
 
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.comonad.ComonadByPure;
 import cyclops.typeclasses.foldable.Foldable;
@@ -69,7 +63,24 @@
  */
 @UtilityClass
 public class Eithers {
-
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproduct(Either<L,T> either, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(either)),def1,Instances.definitions());
+    }
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductR(T right, InstanceDefinitions<W1> def1){
+        return coproduct(Either.right(right),def1);
+    }
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductL(L left, InstanceDefinitions<W1> def1){
+        return coproduct(Either.left(left),def1);
+    }
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorM(Either<L,T> type){
+        return XorM.right(anyM(type));
+    }
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorMR(T right){
+        return XorM.right(anyM(Either.right(right)));
+    }
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorML(L left){
+        return XorM.right(anyM(Either.left(left)));
+    }
     public static <L, R> Either<L, R> xor(Xor<L, R> value) {
         Xor<L, R> xor = (Xor) value.toXor();
         return xor.visit(l -> Either.left(l), r -> Either.right(r));
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
index 0c0a14de..ff362d79 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
@@ -28,10 +28,7 @@
 import cyclops.monads.Witness.*;
 import cyclops.monads.transformers.OptionalT;
 import cyclops.stream.ReactiveSeq;
-import cyclops.typeclasses.Active;
-import cyclops.typeclasses.InstanceDefinitions;
-import cyclops.typeclasses.Nested;
-import cyclops.typeclasses.Pure;
+import cyclops.typeclasses.*;
 import cyclops.typeclasses.comonad.Comonad;
 import cyclops.typeclasses.foldable.Foldable;
 import cyclops.typeclasses.foldable.Unfoldable;
@@ -64,6 +61,16 @@
  */
 @UtilityClass
 public class Options {
+    public static  <W1,T> Coproduct<W1,option,T> coproduct(Option<T> type, InstanceDefinitions<W1> def1){
+        return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
+    }
+    public static  <W1,T> Coproduct<W1,option,T> coproduct(T value, InstanceDefinitions<W1> def1){
+        return coproduct(Option.some(value),def1);
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,option,T> xorM(Option<T> type){
+        return XorM.right(anyM(type));
+    }
+
     public static <T,W extends WitnessType<W>> OptionalT<W, T> liftM(Option<T> opt, W witness) {
         return OptionalT.of(witness.adapter().unit(opt.isSome()? Optional.of(opt.some()) : Optional.empty()));
     }
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
index cc1fbf1a..73aaef8c 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/Optionals.java
@@ -40,6 +40,7 @@
 import cyclops.typeclasses.functor.Functor;
 import cyclops.typeclasses.instances.General;
 import cyclops.typeclasses.monad.*;
+
 import lombok.experimental.UtilityClass;
 import org.reactivestreams.Publisher;
 
@@ -55,10 +56,22 @@
 import static com.aol.cyclops.guava.hkt.OptionalKind.widen;
 import static cyclops.companion.Streams.StreamKind.*;
 
-/**
- * Created by johnmcclean on 26/04/2017.
- */
+
 public class Optionals {
+
+    public static  <W1,T> Coproduct<W1,optional,T> coproduct(T value, InstanceDefinitions<W1> def1){
+        return coproduct(Optional.of(value),def1);
+    }
+    public static  <W1,T> Coproduct<W1,optional,T> coproductAbsent(InstanceDefinitions<W1> def1){
+        return coproduct(Optional.absent(),def1);
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,optional,T> xorM(T present){
+        return XorM.right(anyM(Optional.of(present)));
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,optional,T> xorMAbsent(){
+        return XorM.right(anyM(Optional.absent()));
+    }
+
     /**
      * <pre>
      * {@code
diff --git a/cyclops-vavr/readme.md b/cyclops-vavr/readme.md
index e164ab6f..9bc62d72 100644
--- a/cyclops-vavr/readme.md
+++ b/cyclops-vavr/readme.md
@@ -270,6 +270,23 @@ Option<Integer> opt  = optList.foldsUnsafe()
 
 ```
 
+### Via Coproduct
+
+Coproduct is a Sum type for HKT encoded types that also stores the associated type classes
+
+```java
+import static 
+Coproduct<list,option,Integer> nums = Options.coproduct(10,Lists.Instances.definitions());
+
+
+int value = nums.map(i->i*2)
+                .foldUnsafe()
+                .foldLeft(0,(a,b)->a+b);
+
+//20
+
+```
+
 
 
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
index ad75dade..f5b62d0d 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Arrays.java
@@ -53,6 +53,9 @@ public class Arrays {
     public static  <W1,T> Coproduct<W1,array,T> coproduct(Array<T> list, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(list)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,array,T> coproduct(InstanceDefinitions<W1> def1,T... values){
+        return coproduct(Array.of(values),def1);
+    }
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,array,T> xorM(Array<T> type){
         return XorM.right(anyM(type));
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
index 66bde44e..93ca1c47 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Eithers.java
@@ -64,9 +64,21 @@ public class Eithers {
     public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproduct(Either<L,T> either, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(either)),def1,Instances.definitions());
     }
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductRight(T right, InstanceDefinitions<W1> def1){
+        return coproduct(Either.right(right),def1);
+    }
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductLeft(L left, InstanceDefinitions<W1> def1){
+        return coproduct(Either.left(left),def1);
+    }
     public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorM(Either<L,T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorMRight(T type){
+        return XorM.right(anyM(Either.right(type)));
+    }
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorMLeft(L type){
+        return XorM.right(anyM(Either.left(type)));
+    }
     public static <L, R> Either<L, R> xor(Xor<L, R> value) {
         Xor<L, R> xor = (Xor) value.toXor();
         return xor.visit(l -> Either.left(l), r -> Either.right(r));
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/HashSets.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/HashSets.java
index eb866b3e..7185e0a1 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/HashSets.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/HashSets.java
@@ -54,9 +54,15 @@ public class HashSets {
     public static  <W1,T> Coproduct<W1,hashSet,T> coproduct(HashSet<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,hashSet,T> coproduct(InstanceDefinitions<W1> def1,T... values){
+        return Coproduct.of(Xor.primary(HashSetKind.just(values)),def1, Instances.definitions());
+    }
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,hashSet,T> xorM(HashSet<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,hashSet,T> xorM(T... values){
+        return xorM(HashSet.of(values));
+    }
     public static <T> AnyMSeq<hashSet,T> anyM(HashSet<T> option) {
         return AnyM.ofSeq(option, hashSet.INSTANCE);
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
index 15c9e64d..5ca22073 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lazys.java
@@ -47,6 +47,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 
 import static com.aol.cyclops.vavr.hkt.LazyKind.widen;
@@ -56,6 +57,9 @@ public class Lazys {
     public static  <W1,T> Coproduct<W1,lazy,T> coproduct(Lazy<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,lazy,T> coproduct(Supplier<T> type, InstanceDefinitions<W1> def1){
+        return coproduct(Lazy.of(type),def1);
+    }
 
     /**
      * Lifts a vavr Lazy into a cyclops LazyT monad transformer (involves an observables conversion to
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
index 8f9ec146..e93ec321 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Lists.java
@@ -52,6 +52,9 @@ public static <T,W extends WitnessType<W>> ListT<W, T> liftM(List<T> opt, W witn
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,list,T> xorM(List<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,list,T> xorM(T... values){
+        return xorM(List.of(values));
+    }
 
     public static <T> AnyMSeq<list,T> anyM(List<T> option) {
         return AnyM.ofSeq(option, list.INSTANCE);
@@ -661,6 +664,9 @@ public <R, T> Higher<list, R> unfold(T b, Function<? super T, Optional<Tuple2<R,
     public static  <W1,T> Coproduct<W1,list,T> coproduct(List<T> list, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(ListKind.widen(list)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,list,T> coproduct(InstanceDefinitions<W1> def1,T... values){
+        return Coproduct.of(Xor.primary(ListKind.just(values)),def1, Instances.definitions());
+    }
 
     public static interface ListNested{
 
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
index 7fc93bca..4b4923c7 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Options.java
@@ -69,9 +69,21 @@ public class Options {
     public static  <W1,T> Coproduct<W1,option,T> coproduct(Option<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,option,T> coproduct(T value, InstanceDefinitions<W1> def1){
+        return coproduct(Option.some(value),def1);
+    }
+    public static  <W1,T> Coproduct<W1,option,T> coproductNone(InstanceDefinitions<W1> def1){
+        return coproduct(Option.none(),def1);
+    }
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,option,T> xorM(Option<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,option,T> xorM(T type){
+        return XorM.right(anyM(Option.some(type)));
+    }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,option,T> xorMNone(){
+        return XorM.right(anyM(Option.none()));
+    }
     public static <T,W extends WitnessType<W>> OptionalT<W, T> liftM(Option<T> opt, W witness) {
         return OptionalT.of(witness.adapter().unit(opt.toJavaOptional()));
     }

From 0f9c8a3ec57fc24765d073cc258ed376bdf1232c Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 18:31:49 +0100
Subject: [PATCH 29/30] Coproduct factories

---
 .../java/cyclops/companion/functionaljava/Eithers.java   | 8 ++++----
 .../java/cyclops/companion/functionaljava/Options.java   | 6 ++++++
 .../java/cyclops/companion/guava/FluentIterables.java    | 6 ++++++
 .../src/main/java/cyclops/companion/vavr/Queues.java     | 6 ++++++
 .../src/main/java/cyclops/companion/vavr/Streams.java    | 6 ++++++
 .../src/main/java/cyclops/companion/vavr/Trys.java       | 9 +++++++++
 6 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
index 066daa5f..e7cd73c9 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Eithers.java
@@ -66,19 +66,19 @@ public class Eithers {
     public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproduct(Either<L,T> either, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(either)),def1,Instances.definitions());
     }
-    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductR(T right, InstanceDefinitions<W1> def1){
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductRight(T right, InstanceDefinitions<W1> def1){
         return coproduct(Either.right(right),def1);
     }
-    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductL(L left, InstanceDefinitions<W1> def1){
+    public static  <W1,L,T> Coproduct<W1,Higher<either,L>,T> coproductLeft(L left, InstanceDefinitions<W1> def1){
         return coproduct(Either.left(left),def1);
     }
     public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorM(Either<L,T> type){
         return XorM.right(anyM(type));
     }
-    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorMR(T right){
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorMRight(T right){
         return XorM.right(anyM(Either.right(right)));
     }
-    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorML(L left){
+    public static  <W1 extends WitnessType<W1>,L,T> XorM<W1,either,T> xorMLeft(L left){
         return XorM.right(anyM(Either.left(left)));
     }
     public static <L, R> Either<L, R> xor(Xor<L, R> value) {
diff --git a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
index ff362d79..926da6c0 100644
--- a/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
+++ b/cyclops-functionaljava/src/main/java/cyclops/companion/functionaljava/Options.java
@@ -67,9 +67,15 @@ public static  <W1,T> Coproduct<W1,option,T> coproduct(Option<T> type, InstanceD
     public static  <W1,T> Coproduct<W1,option,T> coproduct(T value, InstanceDefinitions<W1> def1){
         return coproduct(Option.some(value),def1);
     }
+    public static  <W1,T> Coproduct<W1,option,T> coproductNone(InstanceDefinitions<W1> def1){
+        return coproduct(Option.none(),def1);
+    }
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,option,T> xorM(Option<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,option,T> xorMNone(){
+        return xorM(Option.none());
+    }
 
     public static <T,W extends WitnessType<W>> OptionalT<W, T> liftM(Option<T> opt, W witness) {
         return OptionalT.of(witness.adapter().unit(opt.isSome()? Optional.of(opt.some()) : Optional.empty()));
diff --git a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
index 88499683..24f4f9b0 100644
--- a/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
+++ b/cyclops-guava/src/main/java/cyclops/companion/guava/FluentIterables.java
@@ -44,9 +44,15 @@ public class FluentIterables {
     public static  <W1,T> Coproduct<W1,fluentIterable,T> coproduct(FluentIterable<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,fluentIterable,T> coproduct(InstanceDefinitions<W1> def1,T... values){
+        return coproduct(FluentIterable.of(values),def1);
+    }
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,fluentIterable,T> xorM(FluentIterable<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,fluentIterable,T> xorM(T... values){
+        return xorM(FluentIterable.of(values));
+    }
     public static <T,W extends WitnessType<W>> StreamT<W, T> liftM(FluentIterable<T> opt, W witness) {
         return StreamT.of(witness.adapter().unit(ReactiveSeq.fromIterable(opt)));
     }
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
index 53d0d1e5..58ebdd76 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Queues.java
@@ -55,9 +55,15 @@ public class Queues {
     public static  <W1,T> Coproduct<W1,queue,T> coproduct(Queue<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,queue,T> coproduct(InstanceDefinitions<W1> def1,T... values){
+        return  coproduct(Queue.of(values),def1);
+    }
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,queue,T> xorM(Queue<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,queue,T> xorM(T... values){
+        return xorM(Queue.of(values));
+    }
 
     public static <T> AnyMSeq<queue,T> anyM(Queue<T> option) {
         return AnyM.ofSeq(option, queue.INSTANCE);
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
index 5dcba227..d78e696c 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Streams.java
@@ -55,9 +55,15 @@ public class Streams {
     public static  <W1,T> Coproduct<W1,stream,T> coproduct(Stream<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,stream,T> coproduct(InstanceDefinitions<W1> def1,T... values){
+        return coproduct(Stream.of(values),def1);
+    }
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,stream,T> xorM(Stream<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,stream,T> xorM(T... values){
+        return xorM(Stream.of(values));
+    }
    
     public static <T> AnyMSeq<stream,T> anyM(Stream<T> option) {
         return AnyM.ofSeq(option, stream.INSTANCE);
diff --git a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
index 6b6f1719..b0e23ad0 100644
--- a/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
+++ b/cyclops-vavr/src/main/java/cyclops/companion/vavr/Trys.java
@@ -67,9 +67,18 @@ public class Trys {
     public static  <W1 extends WitnessType<W1>,T> XorM<W1,tryType,T> xorM(Try<T> type){
         return XorM.right(anyM(type));
     }
+    public static  <W1 extends WitnessType<W1>,T> XorM<W1,tryType,T> xorM(T type){
+        return xorM(Try.success(type));
+    }
     public static  <W1,T> Coproduct<W1,tryType,T> coproduct(Try<T> type, InstanceDefinitions<W1> def1){
         return Coproduct.of(Xor.primary(widen(type)),def1, Instances.definitions());
     }
+    public static  <W1,T> Coproduct<W1,tryType,T> coproductSuccess(T type, InstanceDefinitions<W1> def1){
+        return coproduct(Try.success(type),def1);
+    }
+    public static  <W1,T> Coproduct<W1,tryType,T> coproductSuccess(Throwable e, InstanceDefinitions<W1> def1){
+        return coproduct(Try.failure(e),def1);
+    }
     public static <T> AnyMValue<tryType,T> anyM(Try<T> tryType) {
         return AnyM.ofValue(tryType, VavrWitness.tryType.INSTANCE);
     }

From 35a0336d55f45d3bc01216d7d400cbcf99fab4a7 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 5 Jul 2017 18:32:41 +0100
Subject: [PATCH 30/30] test gradle

---
 build.gradle | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/build.gradle b/build.gradle
index b904d4bd..e860a365 100644
--- a/build.gradle
+++ b/build.gradle
@@ -20,6 +20,11 @@ repositories {
 
 test {
     systemProperties 'property': 'value'
+	forkEvery = 1
+	//maxParallelForks = Runtime.runtime.availableProcessors()
+	testLogging {
+		events "started","passed", "skipped", "failed"//, "standardOut", "standardError"
+	}
 }