From 4d9f164161c606f62b3f49442ae77cbf60d2d7b0 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Fri, 3 Feb 2017 23:40:26 +0000
Subject: [PATCH 01/14] kleisli

---
 src/main/java/cyclops/monads/Kleisli.java | 67 +++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 src/main/java/cyclops/monads/Kleisli.java

diff --git a/src/main/java/cyclops/monads/Kleisli.java b/src/main/java/cyclops/monads/Kleisli.java
new file mode 100644
index 0000000000..e4b6fcda69
--- /dev/null
+++ b/src/main/java/cyclops/monads/Kleisli.java
@@ -0,0 +1,67 @@
+package cyclops.monads;
+
+
+import com.aol.cyclops2.types.Transformable;
+import cyclops.control.either.Either;
+import cyclops.function.Fn1;
+import lombok.AllArgsConstructor;
+
+import java.util.function.Function;
+
+@AllArgsConstructor
+public class Kleisli<T,R,W extends WitnessType<W>> implements Fn1<T,AnyM<W,R>>,
+                                                                Transformable<R>{
+
+    public final Fn1<T, AnyM<W, R>> fn;
+
+    @Override
+    public AnyM<W,R> apply(T a) {
+
+        return fn.apply(a);
+    }
+
+    public <R1> Kleisli<T,R1,W> map(Function<? super R, ? extends R1> mapper){
+        return kliesli(fn.andThen(am->am.map(mapper)));
+    }
+
+    public <R1> Kleisli<T,R1,W> flatMap(Function<? super R, ? extends AnyM<W,? extends R1>> mapper){
+        return kliesli(fn.andThen(am->am.flatMapA(mapper)));
+    }
+
+    public <A> Kleisli<A,R,W> compose(Kleisli<A,T,W> kleisli) {
+        return new Kleisli<A,R,W>(a -> kleisli.apply(a).flatMapA(this));
+    }
+    public <R2> Kleisli<T,R2,W> then(Kleisli<R,R2,W> kleisli) {
+
+        return new Kleisli<T,R2,W>(t->this.apply(t)
+                                    .flatMapA(kleisli));
+
+    }
+
+    public <T2,R2> Kleisli<Either<T, T2>, Either<R, R2>,W> merge(Kleisli<T2,R2,W> merge, W type) {
+        Kleisli<T, Either<R, R2>, W> first = then(lift(Either::left, type));
+        Kleisli<T2, Either<R, R2>, W> second = merge.then(lift(Either::right, type));
+        return first.fanIn(second);
+
+    }
+
+    public <T2> Kleisli<Either<T, T2>, R,W> fanIn(Kleisli<T2,R,W> fanIn) {
+        return new Kleisli<>(e -> e.visit(this, fanIn));
+    }
+
+
+
+    private static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> kliesli(Function<? super T,? extends AnyM<W,? extends R>> fn){
+        return new Kleisli<T, R, W>(narrow(fn));
+    }
+    private static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> lift(Function<? super T,? extends R> fn, W type){
+        return  kliesli(fn.andThen(r->type.adapter().unit(r)));
+    }
+
+    private static <T, W extends WitnessType<W>, R> Fn1<T,AnyM<W,R>> narrow(Function<? super T, ? extends AnyM<W, ? extends R>> fn) {
+        if(fn instanceof Fn1){
+            return (Fn1)fn;
+        }
+        return in -> (AnyM<W,R>)fn.apply(in);
+    }
+}

From 523d5166afd7f09bf0382fadbf162a2d6444e1f1 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Sat, 4 Feb 2017 21:58:02 +0000
Subject: [PATCH 02/14] more work on kleisli

---
 src/main/java/cyclops/control/Xor.java      |   7 -
 src/main/java/cyclops/function/Fn1.java     |  56 ++
 src/main/java/cyclops/monads/AnyM2.java     | 671 ++++++++++++++++++++
 src/main/java/cyclops/monads/Cokleisli.java |  46 ++
 src/main/java/cyclops/monads/Kleisli.java   |  40 +-
 5 files changed, 802 insertions(+), 18 deletions(-)
 create mode 100644 src/main/java/cyclops/monads/AnyM2.java
 create mode 100644 src/main/java/cyclops/monads/Cokleisli.java

diff --git a/src/main/java/cyclops/control/Xor.java b/src/main/java/cyclops/control/Xor.java
index 9dc91bf4c8..72afa540af 100644
--- a/src/main/java/cyclops/control/Xor.java
+++ b/src/main/java/cyclops/control/Xor.java
@@ -754,13 +754,6 @@ public static <ST, PT> Xor<?, ST> accumulateSecondary(final Monoid<ST> reducer,f
      */
     <R> R visit(Function<? super ST, ? extends R> secondary, Function<? super PT, ? extends R> primary);
 
-    @Deprecated //use bimap instead
-    default <R1, R2> Xor<R1, R2> mapBoth(final Function<? super ST, ? extends R1> secondary, final Function<? super PT, ? extends R2> primary) {
-        if (isSecondary())
-            return (Xor<R1, R2>) swap().map(secondary)
-                                       .swap();
-        return (Xor<R1, R2>) map(primary);
-    }
 
     /* (non-Javadoc)
      * @see com.aol.cyclops2.types.BiFunctor#bimap(java.util.function.Function, java.util.function.Function)
diff --git a/src/main/java/cyclops/function/Fn1.java b/src/main/java/cyclops/function/Fn1.java
index 2a65aa593f..326e027a01 100644
--- a/src/main/java/cyclops/function/Fn1.java
+++ b/src/main/java/cyclops/function/Fn1.java
@@ -5,6 +5,8 @@
 import java.util.function.Function;
 
 import cyclops.control.*;
+import cyclops.control.either.Either;
+import cyclops.monads.Kleisli;
 import cyclops.monads.transformers.FutureT;
 import cyclops.monads.transformers.ListT;
 import cyclops.collections.immutable.PStackX;
@@ -20,6 +22,8 @@
 import org.jooq.lambda.function.Function1;
 import org.jooq.lambda.tuple.Tuple;
 import org.jooq.lambda.tuple.Tuple2;
+import org.jooq.lambda.tuple.Tuple3;
+import org.jooq.lambda.tuple.Tuple4;
 
 @FunctionalInterface
 public interface Fn1<T1,  R> extends Function1<T1,R> {
@@ -62,10 +66,51 @@ default Fn1<T1,R> memoize(Cacheable<R> c){
         return Memoize.memoizeFunction(this,c);
     }
 
+    default <T2,R2> Fn1<Xor<T1, T2>, Xor<R, R2>> merge(Function<? super T2, ? extends R2> fn) {
+        Fn1<T1, Xor<R, R2>> first = andThen(Either::left);
+        Function<? super T2, ? extends Xor<R,R2>> second = fn.andThen(Either::right);
+        return first.fanIn(second);
+
+    }
+
+    default <T2> Fn1<Xor<T1, T2>, R> fanIn(Function<? super T2, ? extends R> fanIn) {
+        return e ->   e.visit(this, fanIn);
+    }
+    default <__> Fn1<Xor<T1, __>, Xor<R, __>> left() {
+
+        return either ->  either.bimap(this,Function.identity());
+    }
+    default <__> Fn1<Xor<__,T1>, Xor<__,R>> right() {
+
+        return either ->  either.bimap(Function.identity(),this);
+    }
+
+
     default <R1> Fn1<T1,Tuple2<R,R1>> product(Fn1<? super T1, ? extends R1> fn){
         return in -> Tuple.tuple(apply(in),fn.apply(in));
     }
 
+    default <__> Fn1<Tuple2<T1, __>, Tuple2<R, __>> first() {
+
+        return t-> Tuple.tuple(apply(t.v1),t.v2);
+    }
+    default <__> Fn1<Tuple2<__, T1>, Tuple2<__, R>> second() {
+
+        return t-> Tuple.tuple(t.v1,apply(t.v2));
+    }
+
+
+
+
+    default <R2,R3> Fn1<T1, Tuple3<R, R2, R3>> product(Function<? super T1, ? extends R2> fn2, Function<? super T1, ? extends R3> fn3) {
+        return a -> Tuple.tuple(apply(a), fn2.apply(a),fn3.apply(a));
+    }
+    default <R2,R3,R4> Fn1<T1, Tuple4<R, R2,R3,R4>> product(Function<? super T1, ? extends R2> fn2,
+                                                           Function<? super T1, ? extends R3> fn3,
+                                                           Function<? super T1, ? extends R4> fn4) {
+        return a -> Tuple.tuple(apply(a), fn2.apply(a),fn3.apply(a),fn4.apply(a));
+    }
+
 
     default Fn0<R> bind(final T1 s) {
         return Curry.curry(this)
@@ -88,6 +133,12 @@ default <V> Fn1<T1, V> andThen(Function<? super R, ? extends V> after) {
 
 
 
+    static <T,R> Fn1<T,R> narrow(Function<? super T, ? extends R> fn){
+        if(fn instanceof Fn1){
+            return (Fn1<T,R>)fn;
+        }
+        return t->fn.apply(t);
+    }
     default FunctionalOperations<T1,R> functionOps(){
         return in->apply(in);
     }
@@ -110,6 +161,11 @@ default <R1> Fn1<T1,R1> coflatMap(final Function<? super Fn1<? super T1,? extend
             return in-> f.apply(this);
         }
 
+
+
+
+
+
         default <W extends WitnessType<W>> AnyM<W, R> mapF(AnyM<W, T1> functor) {
             return functor.map(this);
         }
diff --git a/src/main/java/cyclops/monads/AnyM2.java b/src/main/java/cyclops/monads/AnyM2.java
new file mode 100644
index 0000000000..da3803f5f3
--- /dev/null
+++ b/src/main/java/cyclops/monads/AnyM2.java
@@ -0,0 +1,671 @@
+package cyclops.monads;
+
+import com.aol.cyclops2.data.collections.extensions.CollectionX;
+import com.aol.cyclops2.data.collections.extensions.FluentSequenceX;
+import com.aol.cyclops2.internal.monads.AnyMSeqImpl;
+import com.aol.cyclops2.internal.monads.AnyMValueImpl;
+import com.aol.cyclops2.types.*;
+import com.aol.cyclops2.types.anyM.AnyMSeq;
+import com.aol.cyclops2.types.anyM.AnyMValue;
+import com.aol.cyclops2.types.extensability.FunctionalAdapter;
+import com.aol.cyclops2.types.stream.ToStream;
+import cyclops.Optionals;
+import cyclops.Streams;
+import cyclops.async.Future;
+import cyclops.collections.ListX;
+import cyclops.collections.SetX;
+import cyclops.control.*;
+import cyclops.control.either.Either;
+import cyclops.control.either.Either3;
+import cyclops.control.either.Either4;
+import cyclops.control.either.Either5;
+import cyclops.function.*;
+import cyclops.monads.Witness.*;
+import cyclops.monads.transformers.FutureT;
+import cyclops.monads.transformers.ListT;
+import cyclops.stream.FutureStream;
+import cyclops.stream.ReactiveSeq;
+import cyclops.stream.Streamable;
+import org.jooq.lambda.function.Function3;
+import org.jooq.lambda.function.Function4;
+import org.jooq.lambda.function.Function5;
+import org.jooq.lambda.tuple.Tuple2;
+import org.jooq.lambda.tuple.Tuple3;
+import org.jooq.lambda.tuple.Tuple4;
+import org.reactivestreams.Publisher;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.function.*;
+import java.util.stream.*;
+
+/**
+ * 
+ * Wrapper for Any Monad type
+ * 
+ * There are two subsclass of AnyM - @see {@link AnyMValue} and  @see {@link AnyMSeq}. 
+ * AnyMValue is used to represent Monads that wrap a single value such as {@link Optional}, {@link CompletableFuture}, {@link Maybe}, {@link Eval}, {@link Xor}, {@link Try}, {@link Ior}, {@link FeatureToggle}
+ * AnyMSeq is used to represent Monads that wrap an aggregation of values such as {@link Stream}, {@link FutureStream}, {@link List}, {@link Set}, {@link Streamable}
+ * 
+ * Use AnyM to create your monad wrapper.
+ * AnyM.fromXXXX methods can create the appropriate AnyM type for a range of known monad types.
+ * 
+ * <pre>
+ * {@code 
+ *    AnyMValue<String> monad1 = AnyM.fromOptional(Optional.of("hello"));
+ *    
+ *    AnyMSeq<String> monad2 = AnyM.fromStream(Stream.of("hello","world"));
+ *  
+ * }
+ * </pre>
+ * 
+ * Wrapped monads can be unwrapped via the unwrap method, or converted to the desired type via toXXXX methods
+ * 
+ *
+ * 
+ * @author johnmcclean
+ *
+ * @param <T> type data wrapped by the underlying monad
+ */
+public interface AnyM2<W extends WitnessType<W>,T,T2> extends   AnyM<W,T>,
+                                                                Unwrapable,
+                                                              //  To<AnyM2<W,T,T2>>,
+                                                                EmptyUnit<T>,
+                                                                Unit<T>,
+                                                                Folds<T>,
+                                                                Transformable<T>,
+                                                                ToStream<T>,
+                                                                Zippable<T>,
+                                                                Publisher<T> {
+    @Override
+    default ReactiveSeq<T> reactiveSeq() {
+        return Streams.oneShotStream(StreamSupport.stream(this.spliterator(),false));
+    }
+
+    /**
+     * Collect the contents of the monad wrapped by this AnyM into supplied collector
+     * A mutable reduction operation equivalent to Stream#collect
+     *
+     * <pre>
+     * {@code
+     *      AnyM<Integer> monad1 = AnyM.fromStream(Stream.of(1,2,3));
+     *      AnyM<Integer> monad2 = AnyM.fromOptional(Optional.of(1));
+     *
+     *      List<Integer> list1 = monad1.collect(Collectors.toList());
+     *      List<Integer> list2 = monad2.collect(Collectors.toList());
+     *
+     * }
+     * </pre>
+     *
+     *
+     * @param collector JDK collector to perform mutable reduction
+     * @return Reduced value
+     */
+    default <R, A> R collect(Collector<? super T, A, R> collector){
+        return this.stream().collect(collector);
+    }
+    @Override
+    default Iterator<T> iterator() {
+
+        return adapter().toIterable(this).iterator();
+
+    }
+    
+    default <U> AnyMSeq<W,U> unitIterator(Iterator<U> U){
+        return (AnyMSeq<W,U>)adapter().unitIterable(()->U);
+    }
+
+    <R> AnyM2<W,R,T2> flatMapI(Function<? super T, ? extends Iterable<? extends R>> fn);
+    <R> AnyM2<W,R,T2> flatMapP(Function<? super T, ? extends Publisher<? extends R>> fn);
+    <R> AnyM2<W,R,T2> flatMapS(Function<? super T, ? extends Stream<? extends R>> fn);
+    default <R> AnyM2<W,R,T2> flatMapA(Function<? super T, ? extends AnyM<W, ? extends R>> fn){
+        return adapter().flatMap(this, fn);
+    }
+    default <R> AnyM2<W,R,T2> map(Function<? super T, ? extends R> fn){
+        return adapter().map(this, fn);
+    }
+    default <T> AnyM2<W,T,T2> fromIterable(Iterable<T> t){
+        return  (AnyM2<W,T,T2>)adapter().unitIterable(t);
+    }
+
+    @Override
+    default <R> AnyM2<W,R,T2> zipWith(Iterable<Function<? super T, ? extends R>> fn) {
+        return (AnyM2<W,R,T2>)AnyM.super.zipWith(fn);
+    }
+
+    @Override
+    default <R> AnyM2<W,R,T2> zipWithS(Stream<Function<? super T, ? extends R>> fn) {
+        return (AnyM2<W,R,T2>)AnyM.super.zipWithS(fn);
+    }
+
+    @Override
+    default <R> AnyM2<W,R,T2> zipWithP(Publisher<Function<? super T, ? extends R>> fn) {
+        return (AnyM2<W,R,T2>)AnyM.super.zipWithP(fn);
+    }
+
+    @Override
+    default <R> AnyM2<W,R,T2> retry(final Function<? super T, ? extends R> fn) {
+        return (AnyM2<W,R,T2>)AnyM.super.retry(fn);
+    }
+
+    @Override
+    default <U> AnyM2<W,Tuple2<T, U>,T2> zipP(final Publisher<? extends U> other) {
+        return (AnyM2)AnyM.super.zipP(other);
+    }
+
+    @Override
+    default <R> AnyM2<W,R,T2> retry(final Function<? super T, ? extends R> fn, final int retries, final long delay, final TimeUnit timeUnit) {
+        return (AnyM2<W,R,T2>)AnyM.super.retry(fn,retries,delay,timeUnit);
+    }
+
+    @Override
+    default <S, U> AnyM2<W,Tuple3<T, S, U>,T2> zip3(final Iterable<? extends S> second, final Iterable<? extends U> third) {
+        return (AnyM2)AnyM.super.zip3(second,third);
+    }
+
+    @Override
+    default <S, U, R> AnyM2<W,R,T2> zip3(final Iterable<? extends S> second, final Iterable<? extends U> third, final Fn3<? super T, ? super S, ? super U, ? extends R> fn3) {
+        return (AnyM2<W,R,T2>)AnyM.super.zip3(second,third,fn3);
+    }
+
+    @Override
+    default <T2, T3, T4> AnyM2<W,Tuple4<T, T2, T3, T4>,T2> zip4(final Iterable<? extends T2> second, final Iterable<? extends T3> third, final Iterable<? extends T4> fourth) {
+        return (AnyM2)AnyM.super.zip4(second,third,fourth);
+    }
+
+    @Override
+    default <T2, T3, T4, R> AnyM2<W,R,T2> zip4(final Iterable<? extends T2> second, final Iterable<? extends T3> third, final Iterable<? extends T4> fourth, final Fn4<? super T, ? super T2, ? super T3, ? super T4, ? extends R> fn) {
+        return (AnyM2<W,R,T2>)AnyM.super.zip4(second,third,fourth,fn);
+    }
+
+
+    /**
+     * Construct a new instanceof AnyM using the type of the underlying wrapped monad
+     * 
+     * <pre>
+     * {@code
+     *   AnyM<Integer> ints = AnyM.fromList(Arrays.asList(1,2,3);
+     *   AnyM<String> string = ints.unit("hello");
+     * }
+     * </pre>
+     * 
+     * @param t to embed inside the monad wrapped by AnyM
+     * @return Newly instantated AnyM
+     */
+    @Override
+    default <T> AnyM2<W,T,T2> unit(T t){
+        return adapter().unit(t);
+    }
+    
+    /**
+     * Applicative 'ap' method to use fluently
+     * 
+     * <pre>
+     * {@code 
+     *    AnyM<optional,Function<Integer,Integer>> add = AnyM.fromNullable(this::add2);
+     *    add.to(AnyM::ap)
+     *       .apply(AnyM.ofNullable(10));
+     *   
+     *    //AnyM[12] //add 2
+     * 
+     * }
+     * </pre>
+     * 
+     * @param fn Function inside an Applicative
+     * @return Function to apply an Applicative's value to function
+     */
+    public static <W extends WitnessType<W>,T,T2,R> Function<AnyM2<W,T,T2>,AnyM2<W,R,T2>> ap(AnyM2<W, Function<T, R>,T2> fn){
+        return apply->apply.adapter().ap(fn,apply);
+    }
+    /**
+     * Applicative ap2 method to use fluently to apply to a curried function
+     * <pre>
+     * {@code 
+     *    AnyM<optional,Function<Integer,Function<Integer,Integer>>> add = AnyM.fromNullable(Curry.curry2(this::add));
+     *    add.to(AnyM::ap2)
+     *       .apply(AnyM.ofNullable(10),AnyM.ofNullable(20));
+     *   
+     *    //AnyM[30] //add together
+     * 
+     * }
+     * </pre>
+     * @param fn Curried function inside an Applicative
+     * @return Function to apply two Applicative's values to a function
+     */
+    public static <W extends WitnessType<W>,T,T2,R,T3> BiFunction<AnyM2<W,T,T3>,AnyM2<W,T2,T3>,AnyM2<W,R,T3>> ap2(AnyM2<W, Function<T, Function<T2, R>>,T3> fn){
+        return (apply1,apply2)->apply1.adapter().ap2(fn,apply1,apply2);
+    }
+
+    /**
+     * Perform a filter operation on the wrapped monad instance e.g.
+     * 
+     * <pre>
+     * {@code
+     *   AnyM.fromOptional(Optional.of(10)).filter(i->i<10);
+     * 
+     *   //AnyM[Optional.empty()]
+     *   
+     *   AnyM.fromStream(Stream.of(5,10)).filter(i->i<10);
+     *   
+     *   //AnyM[Stream[5]]
+     * }
+     * 
+     * 
+     * </pre>
+     * 
+     * @param fn Filtering predicate
+     * @return Filtered AnyM
+     */
+    default AnyM2<W,T,T2> filter(Predicate<? super T> fn){
+        return adapter().filter(this, fn);
+    }
+
+
+    default <R> AnyM2<W,R,T2> coflatMapA(final Function<? super AnyM<W, T>, R> mapper) {
+        return unit(Lambda.λ(()->mapper.apply(this))).map(Supplier::get);
+    }
+    
+    
+    default AnyM2<W,AnyM<W,T>,T2> nestA() {
+        return unit(this);
+    }
+    
+    /* (non-Javadoc)
+     * @see com.aol.cyclops2.types.EmptyUnit#emptyUnit()
+     */
+    @Override
+    default <T> Unit<T> emptyUnit(){
+        return adapter().empty();
+    }
+
+    /**
+     * Tests for equivalency between two AnyM types
+     * 
+     * <pre>
+     * {@code
+     *    boolean eqv = AnyM.fromOptional(Optional.of(1)).eqv(AnyM.fromStream(Stream.of(1)));
+     *    //true
+     *     boolean eqv = AnyM.fromOptional(Optional.of(1)).eqv(AnyM.fromStream(Stream.of(1,2)));
+     *    //false
+     * }
+     * </pre>
+     * 
+     * @param t AnyM to check for equivalence with this AnyM
+     * @return true if monads are equivalent
+     */
+    default boolean eqv(final AnyM2<?, T,T2> t) {
+        return Predicates.eqvIterable(t)
+                         .test(this);
+    }
+
+    /**
+     * Allows structural matching on the value / seq nature of this AnyM.
+     * If this AnyM can only store a single value an Xor.secondary with type AnyMValue is returned
+     * If this AnyM can  store one or many values an Xor.primary with type AnyMSeq is returned
+     * 
+     * <pre>
+     * {@code
+     *    AnyM<String> monad;
+     *    
+     *    monad.matchable().visit(v->handleValue(v.get()),s->handleSequence(s.toList()));
+     * }
+     * </pre>
+     * 
+     * 
+     * @return An Xor for pattern matching either an AnyMValue or AnyMSeq
+     */
+    Xor<AnyMValue<W,T>, AnyMSeq<W,T>> matchable();
+
+
+
+
+    /* 
+     * Convert this AnyM to an extended Stream (ReactiveSeq)
+     * 
+     * <pre>
+     * {@code 
+     *    AnyM<Integer> monad =  AnyM.fromOptional(Optional.of(10));
+     *    
+     *    Stream<Integer> reactiveStream = monad.reactiveStream();
+     *    //ReactiveSeq[10]
+     * }
+     * </pre>
+     * 
+     */
+    @Override
+    default ReactiveSeq<T> stream(){
+        return ReactiveSeq.fromIterable(this);
+    }
+
+    
+
+    /**
+     * Perform a peek operation on the wrapped monad e.g.
+     * 
+     * <pre>
+     * {@code 
+     *   AnyM.fromCompletableFuture(CompletableFuture.supplyAsync(()->loadData())
+     *       .peek(System.out::println)
+     * }
+     * </pre>
+     * 
+     * @param c Consumer to accept current data
+     * @return AnyM after peek operation
+     */
+    @Override
+    default AnyM2<W,T,T2> peek(Consumer<? super T> c){
+        return (AnyM2<W, T,T2>) AnyM.super.peek(c);
+    }
+
+
+
+    /**
+     * join / flatten one level of a nested hierarchy
+     * 
+     * @return Flattened / joined one level
+     */ 
+    static <W extends WitnessType<W>,T1,T2> AnyM2<W,T1,T2> flatten(AnyM2<W, ? extends AnyM2<W, T1,T2>,T2> nested){
+        return nested.flatMapA(Function.identity());
+    }
+    static <W extends WitnessType<W>,T1,T2> AnyM2<W,T1,T2> flattenI(AnyM2<W, ? extends Iterable<T1>,T2> nested){
+        return nested.flatMapI(Function.identity());
+    }
+
+   
+    /**
+     * Aggregate the contents of this Monad and the supplied Monad 
+     * 
+     * <pre>{@code 
+     * 
+     * AnyM.fromStream(Stream.of(1,2,3,4))
+     * 							.aggregate(fromEither5(Optional.of(5)))
+     * 
+     * AnyM[Stream[List[1,2,3,4,5]]
+     * 
+     * List<Integer> result = AnyM.fromStream(Stream.of(1,2,3,4))
+     * 							.aggregate(fromEither5(Optional.of(5)))
+     * 							.toSequence()
+     *                          .flatten()
+     * 							.toList();
+    	
+    	assertThat(result,equalTo(Arrays.asList(1,2,3,4,5)));
+    	}</pre>
+     * 
+     * @param next Monad to aggregate content with
+     * @return Aggregated Monad
+     */
+    default AnyM2<W,List<T>,T2> aggregate(AnyM2<W, T,T2> next){
+        return unit(Stream.concat(matchable().visit(value -> value.stream(), seq -> seq.stream()), next.matchable()
+                                  .visit(value -> value.stream(),
+                                         seq -> seq.stream()))
+                    .collect(Collectors.toList()));
+    }
+
+   
+    
+
+    /**
+     * Construct an AnyM wrapping a new empty instance of the wrapped type 
+     * 
+     * e.g.
+     * <pre>
+     * {@code 
+     * Any<Integer> ints = AnyM.fromStream(Stream.of(1,2,3));
+     * AnyM<Integer> empty=ints.empty();
+     * }
+     * </pre>
+     * @return Empty AnyM
+     */
+    default <T> AnyM2<W,T,T2> empty(){
+        return adapter().empty();
+    }
+
+    
+    /**
+     * @return String representation of this AnyM
+     */
+    @Override
+    public String toString();
+
+
+
+    /**
+     * Take an iterable containing Streamables and convert them into a List of AnyMs
+     * e.g.
+     * {@code 
+     *     List<AnyM<Integer>> anyMs = AnyM.listFromStreamable(Arrays.asList(Arrays.asList(1,2,3).iterator(),Arrays.asList(10,20,30)).iterator();
+     *     
+     *     //List[AnyM[Stream[1,2,3],Stream[10,20,30]]]
+     * }
+     * 
+     * @param fromEither5 Iterable containing Iterators
+     * @return List of AnyMs
+     
+    public static <T> ListX<AnyMSeq<T>> listFromIterator(final Iterable<Iterator<T>> fromEither5) {
+        return StreamSupport.reactiveStream(fromEither5.spliterator(), false)
+                            .map(i -> AnyM.fromIterable(() -> i))
+                            .collect(ListX.listXCollector());
+    }*/
+
+    /**
+     * Convert a Collection of Monads to a Monad with a List
+     * 
+     * <pre>
+     * {@code
+        List<CompletableFuture<Integer>> futures = createFutures();
+        AnyM<List<Integer>> futureList = AnyMonads.sequence(AsAnyMList.anyMList(futures));
+    
+       //where AnyM wraps  CompletableFuture<List<Integer>>
+      }</pre>
+     * 
+     * 
+     * @param seq Collection of monads to convert
+     * @return Monad with a List
+     */
+    public static <W extends WitnessType<W>,T1,T2> AnyM2<W,ListX<T1>,T2> sequence(final Collection<? extends AnyM2<W, T1,T2>> seq, W w) {
+        return sequence(seq.stream(),w).map(ListX::fromStreamS);
+    }
+
+    /**
+     * Convert a Collection of Monads to a Monad with a List applying the supplied function in the process
+     * 
+     * <pre>
+     * {@code 
+       List<CompletableFuture<Integer>> futures = createFutures();
+       AnyM<List<String>> futureList = AnyMonads.traverse(AsAnyMList.anyMList(futures), (Integer i) -> "hello" +i);
+        }
+        </pre>
+     * 
+     * @param seq Collection of Monads
+     * @param fn Function to apply 
+     * @return Monad with a list
+     */
+    public static <W extends WitnessType<W>,T, R,T2> AnyM2<W,ListX<R>,T2> traverse(final Collection<? extends AnyM2<W, T,T2>> seq, final Function<? super T, ? extends R> fn, W w) {
+        return sequence(seq,w).map(l->l.map(fn));
+    }
+
+    
+
+
+    public static  <W extends WitnessType<W>,T,T2> AnyM2<W,Stream<T>,T2> sequence(Stream<? extends AnyM2<W, T,T2>> stream, W witness) {
+        FunctionalAdapter<W> c = witness.adapter();
+        AnyM2<W,Stream<T>,T2> identity = c.unit(ReactiveSeq.empty());
+       
+        BiFunction<AnyM2<W,Stream<T>,T2>,AnyM2<W,T,T2>,AnyM2<W,Stream<T>,T2>> combineToStream = (acc, next) -> c.ap2(c.unit(Lambda.l2((Stream<T> a)->(T b)->ReactiveSeq.concat(a,ReactiveSeq.of(b)))),acc,next);
+
+        BinaryOperator<AnyM2<W,Stream<T>,T2>> combineStreams = (a, b)-> (AnyM2<W,Stream<T>,T2>)a.zip(b,(z1, z2)->(Stream<T>)ReactiveSeq.concat(z1,z2)); // a.apply(b, (s1,s2)->s1);
+
+        return stream.reduce(identity,combineToStream,combineStreams);
+    }
+    public static  <W extends WitnessType<W>,T,R,T2> AnyM2<W,Stream<R>,T2> traverse(Function<T, R> fn, Stream<AnyM2<W, T,T2>> stream, W witness) {
+       return sequence(stream.map(h->h.map(fn)),witness);
+    }
+    FunctionalAdapter<W> adapter();
+
+    public static <W extends WitnessType<W>,T,T2> AnyM2<W, T,T2> narrow(AnyM2<W, ? extends T,? extends T2> anyM){
+        return (AnyM2<W,T,T2>)anyM;
+    }
+    
+    /**
+   * Lift a function so it accepts an AnyM and returns an AnyM (any monad)
+   * AnyM view simplifies type related challenges.
+   * 
+   * @param fn
+   * @return
+   */
+  public static <W extends WitnessType<W>,U, R> AnyMFn1<W,U,R> liftF(final Function<? super U, ? extends R> fn) {
+      return u -> u.map(input -> fn.apply(input));
+  }
+
+  /**
+   * Lift a function so it accepts a Monad and returns a Monad (simplex view of a wrapped Monad)
+   * AnyM view simplifies type related challenges. The actual native type is not specified here.
+   * 
+   * e.g.
+   * 
+   * <pre>{@code
+   *  BiFunction<AnyM<Integer>,AnyM<Integer>,AnyM<Integer>> add = Monads.liftF2(this::add);
+   *   
+   *  Optional<Integer> result = add.apply(getBase(),getIncrease());
+   *  
+   *   private Integer add(Integer a, Integer b){
+              return a+b;
+      }
+   * }</pre>
+   * The add method has no null handling, but we can lift the method to Monadic form, and use Optionals to automatically handle null / empty value cases.
+   * 
+   * 
+   * @param fn BiFunction to lift
+   * @return Lifted BiFunction
+   */
+  public static <W extends WitnessType<W>,U1, U2, R> AnyMFn2<W,U1,U2,R> liftF2(
+          final BiFunction<? super U1, ? super U2, ? extends R> fn) {
+
+      return (u1, u2) -> u1.flatMapA(input1 -> u2.map(input2 -> fn.apply(input1, input2)));
+  }
+
+
+  /**
+   * Lift a TriFunction into Monadic form. A good use case it to take an existing method and lift it so it can accept and return monads
+   * 
+   * <pre>
+   * {@code
+   * TriFunction<AnyM<Double>,AnyM<Entity>,AnyM<W,String>,AnyM<Integer>> fn = liftF3(this::myMethod);
+   *    
+   * }
+   * </pre>
+   * 
+   * Now we can execute the Method with Streams, Optional, Futures, Try's etc to transparently inject iteration, null handling, async execution and / or error handling
+   * 
+   * @param fn Function to lift
+   * @return Lifted function
+   */
+  public static <W extends WitnessType<W>,U1, U2, U3, R,T2> Fn3<AnyM2<W,U1,T2>, AnyM2<W,U2,T2>, AnyM2<W,U3,T2>, AnyM2<W,R,T2>> liftF3(
+          final Function3<? super U1, ? super U2, ? super U3, ? extends R> fn) {
+      return (u1, u2, u3) -> u1.flatMapA(input1 -> u2.flatMapA(input2 -> u3.map(input3 -> fn.apply(input1, input2, input3))));
+  }
+
+
+  /**
+   * Lift a QuadFunction into Monadic form.
+   * 
+   * @param fn Quad funciton to lift
+   * @return Lifted Quad function
+   */
+  public static <W extends WitnessType<W>,U1, U2, U3, U4, R,T2> Fn4<AnyM2<W,U1,T2>, AnyM2<W,U2,T2>, AnyM2<W,U3,T2>, AnyM2<W,U4,T2>, AnyM2<W,R,T2>> liftF4(
+          final Function4<? super U1, ? super U2, ? super U3, ? super U4, ? extends R> fn) {
+
+      return (u1, u2, u3, u4) -> u1.flatMapA(input1 -> u2.flatMapA(input2 -> u3.flatMapA(input3 -> u4.map(input4 -> fn.apply(input1, input2, input3, input4)))));
+  }
+
+  /**
+   * Lift a  jOOλ Function5 (5 parameters) into Monadic form
+   * 
+   * @param fn Function to lift
+   * @return Lifted Function
+   */
+  public static <W extends WitnessType<W>,U1, U2, U3, U4, U5, R, T2> Fn5<AnyM2<W,U1,T2>, AnyM2<W,U2,T2>, AnyM2<W,U3,T2>, AnyM2<W,U4,T2>, AnyM2<W,U5,T2>, AnyM2<W,R,T2>> liftF5(
+          final Function5<? super U1, ? super U2, ? super U3, ? super U4, ? super U5, ? extends R> fn) {
+
+      return (u1, u2, u3, u4,
+              u5) -> u1.flatMapA(input1 -> u2.flatMapA(input2 -> u3.flatMapA(input3 -> u4.flatMapA(input4 -> u5.map(input5 -> fn.apply(input1, input2, input3,
+                                                                                                                       input4, input5))))));
+  }
+
+  
+
+  /**
+   * Lift a Curried Function {@code(2 levels a->b->fn.apply(a,b) )} into Monadic form
+   * 
+   * @param fn Function to lift
+   * @return Lifted function 
+   */
+  public static <W extends WitnessType<W>,U1, U2, R, T2> Function<AnyM2<W,U1,T2>, Function<AnyM2<W,U2,T2>, AnyM2<W,R,T2>>> liftF2(final Function<U1, Function<U2, R>> fn) {
+      return u1 -> u2 -> u1.flatMapA(input1 -> u2.map(input2 -> fn.apply(input1)
+                                                              .apply(input2)));
+
+  }
+
+  /**
+   * Lift a Curried Function {@code(3 levels a->b->c->fn.apply(a,b,c) )} into Monadic form
+   * 
+   * @param fn Function to lift
+   * @return Lifted function 
+   */
+  public static <W extends WitnessType<W>,U1, U2, U3, R, T2> Function<AnyM2<W,U1,T2>, Function<AnyM2<W,U2,T2>, Function<AnyM2<W,U3,T2>, AnyM2<W,R,T2>>>> liftF3(
+          final Function<? super U1, Function<? super U2, Function<? super U3, ? extends R>>> fn) {
+      return u1 -> u2 -> u3 -> u1.flatMapA(input1 -> u2.flatMapA(input2 -> u3.map(input3 -> fn.apply(input1)
+                                                                                      .apply(input2)
+                                                                                      .apply(input3))));
+  }
+
+  /**
+   * Lift a Curried Function {@code(4 levels a->b->c->d->fn.apply(a,b,c,d) )} into Monadic form
+   * 
+   * @param fn Function to lift
+   * @return Lifted function 
+   */
+  public static <W extends WitnessType<W>,U1, U2, U3, U4, R,T2> Function<AnyM2<W,U1,T2>, Function<AnyM2<W,U2,T2>, Function<AnyM2<W,U3,T2>, Function<AnyM2<W,U4,T2>, AnyM2<W,R,T2>>>>> liftF4(
+          final Function<? super U1, Function<? super U2, Function<? super U3, Function<? super U4, ? extends R>>>> fn) {
+
+      return u1 -> u2 -> u3 -> u4 -> u1.flatMapA(input1 -> u2.flatMapA(input2 -> u3.flatMapA(input3 -> u4.map(input4 -> fn.apply(input1)
+                                                                                                              .apply(input2)
+                                                                                                              .apply(input3)
+                                                                                                              .apply(input4)))));
+  }
+
+  /**
+   * Lift a Curried Function {@code (5 levels a->b->c->d->e->fn.apply(a,b,c,d,e) ) }into Monadic form
+   * 
+   * @param fn Function to lift
+   * @return Lifted function 
+   */
+  public static <W extends WitnessType<W>,U1, U2, U3, U4, U5, R, T2> Function<AnyM2<W,U1,T2>, Function<AnyM2<W,U2,T2>, Function<AnyM2<W,U3,T2>, Function<AnyM2<W,U4,T2>, Function<AnyM2<W,U5,T2>, AnyM2<W,R,T2>>>>>> liftF5(
+          final Function<? super U1, Function<? super U2, Function<? super U3, Function<? super U4, Function<? super U5, ? extends R>>>>> fn) {
+
+      return u1 -> u2 -> u3 -> u4 -> u5 -> u1.flatMapA(input1 -> u2.flatMapA(input2 -> u3.flatMapA(input3 -> u4.flatMapA(input4 -> u5.map(input5 -> fn.apply(input1)
+                                                                                                                                      .apply(input2)
+                                                                                                                                      .apply(input3)
+                                                                                                                                      .apply(input4)
+                                                                                                                                      .apply(input5))))));
+  }
+
+    default FutureT<W, T> liftMFuture(Function<? super T, ? extends Future<T>> lift) {
+
+        return FutureT.of(this.map(a -> lift.apply(a)));
+    }
+
+    default ListT<W, T> liftMList(Function<? super T, ? extends FluentSequenceX<T>> lift) {
+        return ListT.of(this.map(a -> lift.apply(a)));
+    }
+
+    default FutureT<W, T> liftMFuture() {
+        return FutureT.of(this.map(a -> Future.ofResult(a)));
+    }
+
+    default ListT<W, T> liftMListX() {
+        return ListT.of(this.map(a -> ListX.of(a)));
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/cyclops/monads/Cokleisli.java b/src/main/java/cyclops/monads/Cokleisli.java
new file mode 100644
index 0000000000..afa32e8276
--- /dev/null
+++ b/src/main/java/cyclops/monads/Cokleisli.java
@@ -0,0 +1,46 @@
+package cyclops.monads;
+
+
+import com.aol.cyclops2.types.Transformable;
+import cyclops.control.Xor;
+import cyclops.function.Fn1;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import org.jooq.lambda.tuple.Tuple2;
+
+import java.util.function.Function;
+
+@AllArgsConstructor(access= AccessLevel.PRIVATE)
+public class Cokleisli<T,R,W extends WitnessType<W>> implements Fn1<AnyM<W,T>,R>,
+                                                                Transformable<R>{
+
+    public final Fn1<AnyM<W, T>,R> fn;
+
+
+    @Override
+    public R apply(AnyM<W, T> a) {
+        return fn.apply(a);
+    }
+    public <R1> Cokleisli<T,R1,W> map(Function<? super R, ? extends R1> mapper){
+        return cokleisli(fn.andThen(mapper));
+    }
+
+    public <R2> Cokleisli<T, Tuple2<R, R2>,W> fanout(Cokleisli<T, R2, W> f2) {
+        return product(f2);
+
+    }
+
+    public <R2> Cokleisli<T, Tuple2<R, R2>,W> product(Cokleisli<T, R2, W> f2) {
+        return cokleisli(fn.product(f2));
+    }
+
+
+
+    public static <T,R,W extends WitnessType<W>> Cokleisli<T,R,W> cokleisli(Function<? super AnyM<W,T>,? extends R> fn){
+        return new Cokleisli<T, R, W>(Fn1.narrow(fn));
+    }
+
+
+
+
+}
diff --git a/src/main/java/cyclops/monads/Kleisli.java b/src/main/java/cyclops/monads/Kleisli.java
index e4b6fcda69..f92f320b14 100644
--- a/src/main/java/cyclops/monads/Kleisli.java
+++ b/src/main/java/cyclops/monads/Kleisli.java
@@ -2,17 +2,21 @@
 
 
 import com.aol.cyclops2.types.Transformable;
-import cyclops.control.either.Either;
+import cyclops.control.Xor;
 import cyclops.function.Fn1;
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.function.Function;
 
-@AllArgsConstructor
+@AllArgsConstructor(access= AccessLevel.PRIVATE)
 public class Kleisli<T,R,W extends WitnessType<W>> implements Fn1<T,AnyM<W,R>>,
                                                                 Transformable<R>{
 
     public final Fn1<T, AnyM<W, R>> fn;
+    private final W type = null;
 
     @Override
     public AnyM<W,R> apply(T a) {
@@ -21,11 +25,11 @@ public AnyM<W,R> apply(T a) {
     }
 
     public <R1> Kleisli<T,R1,W> map(Function<? super R, ? extends R1> mapper){
-        return kliesli(fn.andThen(am->am.map(mapper)));
+        return kleisli(fn.andThen(am->am.map(mapper)));
     }
 
     public <R1> Kleisli<T,R1,W> flatMap(Function<? super R, ? extends AnyM<W,? extends R1>> mapper){
-        return kliesli(fn.andThen(am->am.flatMapA(mapper)));
+        return kleisli(fn.andThen(am->am.flatMapA(mapper)));
     }
 
     public <A> Kleisli<A,R,W> compose(Kleisli<A,T,W> kleisli) {
@@ -38,24 +42,38 @@ public <R2> Kleisli<T,R2,W> then(Kleisli<R,R2,W> kleisli) {
 
     }
 
-    public <T2,R2> Kleisli<Either<T, T2>, Either<R, R2>,W> merge(Kleisli<T2,R2,W> merge, W type) {
-        Kleisli<T, Either<R, R2>, W> first = then(lift(Either::left, type));
-        Kleisli<T2, Either<R, R2>, W> second = merge.then(lift(Either::right, type));
+    public <__> Kleisli<Xor<T, __>, Xor<R, __>,W> leftK() {
+         return kleisli(xr -> xr.visit(l -> fn.apply(l).map(Xor::secondary), r -> type.adapter().unit(r).map(Xor::primary)));
+    }
+    public <__> Kleisli<Xor<__,T>, Xor<__,R>,W> rightK() {
+        return kleisli(xr -> xr.visit(l -> type.adapter().unit(l).map(Xor::secondary), r -> fn.apply(r).map(Xor::primary)));
+    }
+    public <__> Kleisli<Tuple2<T, __>, Tuple2<R, __>,W> firstK() {
+        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v1).map(r1-> Tuple.tuple(r1,v2))));
+    }
+    public <__> Kleisli<Tuple2<__,T>, Tuple2<__,R>,W> secondK() {
+        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v2).map(r2-> Tuple.tuple(v1,r2))));
+    }
+
+
+    public <T2,R2> Kleisli<Xor<T, T2>, Xor<R, R2>,W> merge(Kleisli<T2,R2,W> merge, W type) {
+        Kleisli<T, Xor<R, R2>, W> first = then(lift(Xor::secondary, type));
+        Kleisli<T2, Xor<R, R2>, W> second = merge.then(lift(Xor::primary, type));
         return first.fanIn(second);
 
     }
 
-    public <T2> Kleisli<Either<T, T2>, R,W> fanIn(Kleisli<T2,R,W> fanIn) {
+    public <T2> Kleisli<Xor<T, T2>, R,W> fanIn(Kleisli<T2,R,W> fanIn) {
         return new Kleisli<>(e -> e.visit(this, fanIn));
     }
 
 
 
-    private static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> kliesli(Function<? super T,? extends AnyM<W,? extends R>> fn){
+    public static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> kleisli(Function<? super T,? extends AnyM<W,? extends R>> fn){
         return new Kleisli<T, R, W>(narrow(fn));
     }
-    private static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> lift(Function<? super T,? extends R> fn, W type){
-        return  kliesli(fn.andThen(r->type.adapter().unit(r)));
+    public static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> lift(Function<? super T,? extends R> fn, W type){
+        return  kleisli(fn.andThen(r->type.adapter().unit(r)));
     }
 
     private static <T, W extends WitnessType<W>, R> Fn1<T,AnyM<W,R>> narrow(Function<? super T, ? extends AnyM<W, ? extends R>> fn) {

From 741a3aaf5dc3340f24947a188251f57a108c74c9 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Sun, 5 Feb 2017 00:29:25 +0000
Subject: [PATCH 03/14] wip

---
 .../cyclops/control/ReaderWriterState.java    |  42 ++++
 src/main/java/cyclops/control/State.java      | 203 ++++++++++++++++++
 src/main/java/cyclops/control/Writer.java     | 194 +++++++++++++++++
 src/main/java/cyclops/function/Coreader.java  |  33 +++
 src/main/java/cyclops/function/Fn1.java       |   8 +-
 src/main/java/cyclops/monads/AnyM2.java       |  18 +-
 src/main/java/cyclops/monads/Kleisli.java     |  26 +--
 .../com/aol/cyclops2/control/Xor2Test.java    |   4 +-
 src/test/java/cyclops/control/StateTest.java  |  40 ++++
 src/test/java/cyclops/free/FreeTest.java      |   1 +
 10 files changed, 541 insertions(+), 28 deletions(-)
 create mode 100644 src/main/java/cyclops/control/ReaderWriterState.java
 create mode 100644 src/main/java/cyclops/control/State.java
 create mode 100644 src/main/java/cyclops/control/Writer.java
 create mode 100644 src/main/java/cyclops/function/Coreader.java
 create mode 100644 src/test/java/cyclops/control/StateTest.java

diff --git a/src/main/java/cyclops/control/ReaderWriterState.java b/src/main/java/cyclops/control/ReaderWriterState.java
new file mode 100644
index 0000000000..dc8630a7b9
--- /dev/null
+++ b/src/main/java/cyclops/control/ReaderWriterState.java
@@ -0,0 +1,42 @@
+package cyclops.control;
+
+import cyclops.free.Free;
+import cyclops.function.*;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
+
+import java.util.function.Function;
+
+/**
+ * Created by johnmcclean on 05/02/2017.
+ */
+public class ReaderWriterState<R,W,S,T>  {
+
+
+    Reader<S, Free<Fn0.SupplierKind.µ,Tuple2<Writer<W, S>, T>>> runState;
+
+    public Tuple2<Writer<W,S>,T> run(S s) {
+        return Fn0.run(runState.apply(s));
+    }
+    public T eval(S s) {
+        return Fn0.run(runState.apply(s)).v2;
+    }
+    public <R> State<S, R> map(Function<? super T,? extends R> mapper) {
+        return mapState(t -> Tuple.tuple(t.v1, mapper.apply(t.v2)));
+    }
+    public <R> State<S, R> mapState(Function<Tuple2<S,T>, Tuple2<S, R>> fn) {
+        return suspended(s -> runState.apply(s).map(t -> fn.apply(t.map((w,r)->w.getValue().map2(__->r)))));
+    }
+    private static <S, T> State<S, T> suspended(Fn1<? super S, Free<Fn0.SupplierKind.µ,Tuple2<S, T>>> runF) {
+        return new State<>(s -> Fn0.suspend(Lambda.λK(()->runF.apply(s))));
+    }
+
+    public <R> State<S, R> flatMap(Function<? super T,? extends  State<S, R>> f) {
+        return suspended(s -> runState.apply(s).flatMap(result -> Free.done(f.apply(result.v2).run(result.v1))));
+    }
+
+    public static <R,W,S,T> ReaderWriterState<R,W,S,T> rws(Function<? super S,? extends Tuple2<S, T>> runF, Monoid<W> monoid) {
+
+        return new State<>(s -> Free.done(runF.apply(s)));
+    }
+}
diff --git a/src/main/java/cyclops/control/State.java b/src/main/java/cyclops/control/State.java
new file mode 100644
index 0000000000..e9008dae33
--- /dev/null
+++ b/src/main/java/cyclops/control/State.java
@@ -0,0 +1,203 @@
+package cyclops.control;
+
+import cyclops.control.Maybe.Nothing;
+import cyclops.free.Free;
+import cyclops.function.*;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public final class State<S, T> {
+
+    private final Fn1<S, Free<Fn0.SupplierKind.µ,Tuple2<S, T>>> runState;
+
+
+    public Tuple2<S, T> run(S s) {
+        return Fn0.run(runState.apply(s));
+    }
+    public T eval(S s) {
+        return Fn0.run(runState.apply(s)).v2;
+    }
+    public static <S> State<S, S> get() {
+        return state(s -> Tuple.tuple(s, s));
+    }
+
+    public static <S> State<S, Nothing> transition(Function<? super S,? extends S> f) {
+        return state(s -> Tuple.tuple(f.apply(s),(Nothing)Maybe.none()));
+    }
+
+    public static <S, T> State<S, T> transition(Function<? super S,? extends S> f, T value) {
+        return state(s -> Tuple.tuple(f.apply(s),value));
+    }
+
+    public <R> State<S, R> map(Function<? super T,? extends R> mapper) {
+        return mapState(t -> Tuple.tuple(t.v1, mapper.apply(t.v2)));
+    }
+    public <R> State<S, R> mapState(Function<Tuple2<S,T>, Tuple2<S, R>> fn) {
+        return suspended(s -> runState.apply(s).map(t -> fn.apply(t)));
+    }
+    private static <S, T> State<S, T> suspended(Fn1<? super S, Free<Fn0.SupplierKind.µ,Tuple2<S, T>>> runF) {
+        return new State<>(s -> Fn0.suspend(Lambda.λK(()->runF.apply(s))));
+    }
+
+    public <R> State<S, R> flatMap(Function<? super T,? extends  State<S, R>> f) {
+        return suspended(s -> runState.apply(s).flatMap(t -> Free.done(f.apply(t.v2).run(t.v1))));
+    }
+    public static <S, T> State<S, T> constant(T constant) {
+        return state(s -> Tuple.tuple(s, constant));
+    }
+
+    /*
+  * Perform a For Comprehension over a State, accepting 3 generating function.
+          * This results in a four level nested internal iteration over the provided States.
+   *
+           *  <pre>
+   * {@code
+   *
+   *   import static com.aol.cyclops2.reactor.States.forEach4;
+   *
+      forEach4(State.just(1),
+              a-> State.just(a+1),
+              (a,b) -> State.<Integer>just(a+b),
+              a                  (a,b,c) -> State.<Integer>just(a+b+c),
+              Tuple::tuple)
+   *
+   * }
+   * </pre>
+          *
+          * @param value1 top level State
+   * @param value2 Nested State
+   * @param value3 Nested State
+   * @param value4 Nested State
+   * @param yieldingFunction Generates a result per combination
+   * @return State with a combined value generated by the yielding function
+   */
+    public  <R1, R2, R3, R4> State<S,R4> forEach4(Function<? super T, ? extends State<S,R1>> value2,
+                                                  BiFunction<? super T, ? super R1, ? extends State<S,R2>> value3,
+                                                  Fn3<? super T, ? super R1, ? super R2, ? extends State<S,R3>> value4,
+                                                  Fn4<? super T, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
+
+
+        return this.flatMap(in -> {
+
+            State<S,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                State<S,R2> b = value3.apply(in,ina);
+                return b.flatMap(inb -> {
+
+                    State<S,R3> c = value4.apply(in,ina,inb);
+
+                    return c.map(in2 -> {
+
+                        return yieldingFunction.apply(in, ina, inb, in2);
+
+                    });
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+
+
+
+    /**
+     * Perform a For Comprehension over a State, accepting 2 generating function.
+     * This results in a three level nested internal iteration over the provided States.
+     *
+     *  <pre>
+     * {@code
+     *
+     *   import static com.aol.cyclops2.reactor.States.forEach3;
+     *
+    forEach3(State.just(1),
+    a-> State.just(a+1),
+    (a,b) -> State.<Integer>just(a+b),
+    Tuple::tuple)
+     *
+     * }
+     * </pre>
+     *
+     * @param value1 top level State
+     * @param value2 Nested State
+     * @param value3 Nested State
+     * @param yieldingFunction Generates a result per combination
+     * @return State with a combined value generated by the yielding function
+     */
+    public <R1, R2, R4> State<S,R4> forEach3(Function<? super T, ? extends State<S,R1>> value2,
+                                             BiFunction<? super T, ? super R1, ? extends State<S,R2>> value3,
+                                             Fn3<? super T, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            State<S,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                State<S,R2> b = value3.apply(in,ina);
+                return b.map(in2 -> {
+                    return yieldingFunction.apply(in, ina, in2);
+
+                });
+
+
+
+            });
+
+        });
+
+    }
+
+
+    /**
+     * Perform a For Comprehension over a State, accepting a generating function.
+     * This results in a two level nested internal iteration over the provided States.
+     *
+     *  <pre>
+     * {@code
+     *
+     *   import static com.aol.cyclops2.reactor.States.forEach;
+     *
+    forEach(State.just(1),
+    a-> State.just(a+1),
+    Tuple::tuple)
+     *
+     * }
+     * </pre>
+     *
+     * @param value1 top level State
+     * @param value2 Nested State
+     * @param yieldingFunction Generates a result per combination
+     * @return State with a combined value generated by the yielding function
+     */
+    public <R1, R4> State<S,R4> forEach2(Function<? super T, State<S,R1>> value2,
+                                         BiFunction<? super T, ? super R1, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            State<S,R1> a = value2.apply(in);
+            return a.map(in2 -> {
+                return yieldingFunction.apply(in, in2);
+
+            });
+
+        });
+
+    }
+
+    public static <S, T> State<S, T> state(Function<? super S,? extends Tuple2<S, T>> runF) {
+
+        return new State<>(s -> Free.done(runF.apply(s)));
+    }
+
+
+
+
+}
\ No newline at end of file
diff --git a/src/main/java/cyclops/control/Writer.java b/src/main/java/cyclops/control/Writer.java
new file mode 100644
index 0000000000..f626f1287e
--- /dev/null
+++ b/src/main/java/cyclops/control/Writer.java
@@ -0,0 +1,194 @@
+package cyclops.control;
+
+import com.aol.cyclops2.types.MonadicValue;
+import com.aol.cyclops2.types.Transformable;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Monoid;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.val;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+@AllArgsConstructor(access= AccessLevel.PRIVATE)
+@Getter
+public final class Writer<W, T> implements Transformable<T>, Iterable<T> {
+
+    private final Tuple2<T,W> value;
+    private final Monoid<W> monoid;
+
+    public <R> Writer<W, R> map(Function<? super T,? extends  R> mapper) {
+        return writer(mapper.apply(value.v1), value.v2, monoid);
+    }
+
+    public <R> Writer<W, R> flatMap(Function<? super T,? extends  Writer<W, ? extends R>> fn) {
+        Writer<W, ? extends R> writer = fn.apply(value.v1);
+        return writer(writer.value.v1, writer.monoid.apply(value.v2, writer.value.v2), writer.monoid);
+    }
+
+    public Writer<W,T> write(W write){
+        return writer(value.v1,monoid.apply(write,value.v2),monoid);
+    }
+
+    /*
+     * Perform a For Comprehension over a Writer, accepting 3 generating function.
+             * This results in a four level nested internal iteration over the provided Writers.
+      *
+              *  <pre>
+      * {@code
+      *
+      *   import static com.aol.cyclops2.reactor.Writers.forEach4;
+      *
+         forEach4(Writer.just(1),
+                 a-> Writer.just(a+1),
+                 (a,b) -> Writer.<Integer>just(a+b),
+                 a                  (a,b,c) -> Writer.<Integer>just(a+b+c),
+                 Tuple::tuple)
+      *
+      * }
+      * </pre>
+             *
+             * @param value1 top level Writer
+      * @param value2 Nested Writer
+      * @param value3 Nested Writer
+      * @param value4 Nested Writer
+      * @param yieldingFunction Generates a result per combination
+      * @return Writer with a combined value generated by the yielding function
+      */
+    public  <R1, R2, R3, R4> Writer<W,R4> forEach4(Function<? super T, ? extends Writer<W,R1>> value2,
+                                                   BiFunction<? super T, ? super R1, ? extends Writer<W,R2>> value3,
+                                                   Fn3<? super T, ? super R1, ? super R2, ? extends Writer<W,R3>> value4,
+                                                   Fn4<? super T, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
+
+
+        return this.flatMap(in -> {
+
+            Writer<W,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Writer<W,R2> b = value3.apply(in,ina);
+                return b.flatMap(inb -> {
+
+                    Writer<W,R3> c = value4.apply(in,ina,inb);
+
+                    return c.map(in2 -> {
+
+                        return yieldingFunction.apply(in, ina, inb, in2);
+
+                    });
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+
+
+
+    /**
+     * Perform a For Comprehension over a Writer, accepting 2 generating function.
+     * This results in a three level nested internal iteration over the provided Writers.
+     *
+     *  <pre>
+     * {@code
+     *
+     *   import static com.aol.cyclops2.reactor.Writers.forEach3;
+     *
+    forEach3(Writer.just(1),
+    a-> Writer.just(a+1),
+    (a,b) -> Writer.<Integer>just(a+b),
+    Tuple::tuple)
+     *
+     * }
+     * </pre>
+     *
+     * @param value1 top level Writer
+     * @param value2 Nested Writer
+     * @param value3 Nested Writer
+     * @param yieldingFunction Generates a result per combination
+     * @return Writer with a combined value generated by the yielding function
+     */
+    public <R1, R2, R4> Writer<W,R4> forEach3(Function<? super T, ? extends Writer<W,R1>> value2,
+                                               BiFunction<? super T, ? super R1, ? extends Writer<W,R2>> value3,
+                                               Fn3<? super T, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            Writer<W,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Writer<W,R2> b = value3.apply(in,ina);
+                return b.map(in2 -> {
+                    return yieldingFunction.apply(in, ina, in2);
+
+                });
+
+
+
+            });
+
+        });
+
+    }
+
+
+    /**
+     * Perform a For Comprehension over a Writer, accepting a generating function.
+     * This results in a two level nested internal iteration over the provided Writers.
+     *
+     *  <pre>
+     * {@code
+     *
+     *   import static com.aol.cyclops2.reactor.Writers.forEach;
+     *
+    forEach(Writer.just(1),
+    a-> Writer.just(a+1),
+    Tuple::tuple)
+     *
+     * }
+     * </pre>
+     *
+     * @param value1 top level Writer
+     * @param value2 Nested Writer
+     * @param yieldingFunction Generates a result per combination
+     * @return Writer with a combined value generated by the yielding function
+     */
+    public <R1, R4> Writer<W,R4> forEach2(Function<? super T, Writer<W,R1>> value2,
+                                           BiFunction<? super T, ? super R1, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            Writer<W,R1> a = value2.apply(in);
+            return a.map(in2 -> {
+                return yieldingFunction.apply(in, in2);
+
+            });
+
+        });
+
+    }
+
+    public static <W, T> Writer<W, T> writer(T value, Monoid<W> combiner) {
+        return new Writer<W,T>(Tuple.tuple(value, combiner.zero()), combiner);
+    }
+    public static <W, T> Writer<W, T> writer(T value, W initial, Monoid<W> combiner) {
+        return new Writer<W,T>(Tuple.tuple(value, initial), combiner);
+    }
+    public static <W, T> Writer<W, T> writer(Tuple2<T,W> values, Monoid<W> combiner) {
+        return new Writer<W,T>(values, combiner);
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return Arrays.asList(value.v1).iterator();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cyclops/function/Coreader.java b/src/main/java/cyclops/function/Coreader.java
new file mode 100644
index 0000000000..cf2357905b
--- /dev/null
+++ b/src/main/java/cyclops/function/Coreader.java
@@ -0,0 +1,33 @@
+package cyclops.function;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Value;
+
+import java.util.function.Function;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class Coreader<R, T> {
+
+    private final T extract;
+    private final R ask;
+
+
+    public <B> Coreader<R,B> map(Function<? super T,? extends B> fn) {
+        return new Coreader<R,B>( fn.apply(extract),ask);
+    }
+
+    public Coreader<R, Coreader<R, T>> nest() {
+        return new Coreader<>(this,ask);
+    }
+
+    public <B> Coreader<R,B> coflatMap(Function<? super Coreader<R, T>,? extends B> fn) {
+        return nest().map(fn);
+    }
+
+    public static <R,T> Coreader<R,T> coreader(T extract, R ask){
+        return new Coreader<>(extract,ask);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cyclops/function/Fn1.java b/src/main/java/cyclops/function/Fn1.java
index 326e027a01..7e5a547d54 100644
--- a/src/main/java/cyclops/function/Fn1.java
+++ b/src/main/java/cyclops/function/Fn1.java
@@ -76,11 +76,11 @@ default <T2,R2> Fn1<Xor<T1, T2>, Xor<R, R2>> merge(Function<? super T2, ? extend
     default <T2> Fn1<Xor<T1, T2>, R> fanIn(Function<? super T2, ? extends R> fanIn) {
         return e ->   e.visit(this, fanIn);
     }
-    default <__> Fn1<Xor<T1, __>, Xor<R, __>> left() {
+    default <__> Fn1<Xor<T1, __>, Xor<R, __>> leftFn() {
 
         return either ->  either.bimap(this,Function.identity());
     }
-    default <__> Fn1<Xor<__,T1>, Xor<__,R>> right() {
+    default <__> Fn1<Xor<__,T1>, Xor<__,R>> rightFn() {
 
         return either ->  either.bimap(Function.identity(),this);
     }
@@ -90,11 +90,11 @@ default <R1> Fn1<T1,Tuple2<R,R1>> product(Fn1<? super T1, ? extends R1> fn){
         return in -> Tuple.tuple(apply(in),fn.apply(in));
     }
 
-    default <__> Fn1<Tuple2<T1, __>, Tuple2<R, __>> first() {
+    default <__> Fn1<Tuple2<T1, __>, Tuple2<R, __>> firstFn() {
 
         return t-> Tuple.tuple(apply(t.v1),t.v2);
     }
-    default <__> Fn1<Tuple2<__, T1>, Tuple2<__, R>> second() {
+    default <__> Fn1<Tuple2<__, T1>, Tuple2<__, R>> secondFn() {
 
         return t-> Tuple.tuple(t.v1,apply(t.v2));
     }
diff --git a/src/main/java/cyclops/monads/AnyM2.java b/src/main/java/cyclops/monads/AnyM2.java
index da3803f5f3..f8d3a7bf80 100644
--- a/src/main/java/cyclops/monads/AnyM2.java
+++ b/src/main/java/cyclops/monads/AnyM2.java
@@ -120,10 +120,10 @@ default <U> AnyMSeq<W,U> unitIterator(Iterator<U> U){
     <R> AnyM2<W,R,T2> flatMapP(Function<? super T, ? extends Publisher<? extends R>> fn);
     <R> AnyM2<W,R,T2> flatMapS(Function<? super T, ? extends Stream<? extends R>> fn);
     default <R> AnyM2<W,R,T2> flatMapA(Function<? super T, ? extends AnyM<W, ? extends R>> fn){
-        return adapter().flatMap(this, fn);
+        return (AnyM2<W,R,T2>)adapter().flatMap(this, fn);
     }
     default <R> AnyM2<W,R,T2> map(Function<? super T, ? extends R> fn){
-        return adapter().map(this, fn);
+        return (AnyM2<W,R,T2>)adapter().map(this, fn);
     }
     default <T> AnyM2<W,T,T2> fromIterable(Iterable<T> t){
         return  (AnyM2<W,T,T2>)adapter().unitIterable(t);
@@ -195,7 +195,7 @@ default <T2, T3, T4, R> AnyM2<W,R,T2> zip4(final Iterable<? extends T2> second,
      */
     @Override
     default <T> AnyM2<W,T,T2> unit(T t){
-        return adapter().unit(t);
+        return (AnyM2<W,T,T2>)adapter().unit(t);
     }
     
     /**
@@ -216,7 +216,7 @@ default <T> AnyM2<W,T,T2> unit(T t){
      * @return Function to apply an Applicative's value to function
      */
     public static <W extends WitnessType<W>,T,T2,R> Function<AnyM2<W,T,T2>,AnyM2<W,R,T2>> ap(AnyM2<W, Function<T, R>,T2> fn){
-        return apply->apply.adapter().ap(fn,apply);
+        return apply->(AnyM2<W,R,T2>)apply.adapter().ap(fn,apply);
     }
     /**
      * Applicative ap2 method to use fluently to apply to a curried function
@@ -234,7 +234,7 @@ public static <W extends WitnessType<W>,T,T2,R> Function<AnyM2<W,T,T2>,AnyM2<W,R
      * @return Function to apply two Applicative's values to a function
      */
     public static <W extends WitnessType<W>,T,T2,R,T3> BiFunction<AnyM2<W,T,T3>,AnyM2<W,T2,T3>,AnyM2<W,R,T3>> ap2(AnyM2<W, Function<T, Function<T2, R>>,T3> fn){
-        return (apply1,apply2)->apply1.adapter().ap2(fn,apply1,apply2);
+        return (apply1,apply2)->(AnyM2<W,R,T3>)apply1.adapter().ap2(fn,apply1,apply2);
     }
 
     /**
@@ -258,7 +258,7 @@ public static <W extends WitnessType<W>,T,T2,R,T3> BiFunction<AnyM2<W,T,T3>,AnyM
      * @return Filtered AnyM
      */
     default AnyM2<W,T,T2> filter(Predicate<? super T> fn){
-        return adapter().filter(this, fn);
+        return (AnyM2<W,T,T2>)adapter().filter(this, fn);
     }
 
 
@@ -418,7 +418,7 @@ default AnyM2<W,List<T>,T2> aggregate(AnyM2<W, T,T2> next){
      * @return Empty AnyM
      */
     default <T> AnyM2<W,T,T2> empty(){
-        return adapter().empty();
+        return (AnyM2<W,T,T2>)adapter().empty();
     }
 
     
@@ -490,9 +490,9 @@ public static <W extends WitnessType<W>,T, R,T2> AnyM2<W,ListX<R>,T2> traverse(f
 
     public static  <W extends WitnessType<W>,T,T2> AnyM2<W,Stream<T>,T2> sequence(Stream<? extends AnyM2<W, T,T2>> stream, W witness) {
         FunctionalAdapter<W> c = witness.adapter();
-        AnyM2<W,Stream<T>,T2> identity = c.unit(ReactiveSeq.empty());
+        AnyM2<W,Stream<T>,T2> identity = ( AnyM2)c.unit(ReactiveSeq.empty());
        
-        BiFunction<AnyM2<W,Stream<T>,T2>,AnyM2<W,T,T2>,AnyM2<W,Stream<T>,T2>> combineToStream = (acc, next) -> c.ap2(c.unit(Lambda.l2((Stream<T> a)->(T b)->ReactiveSeq.concat(a,ReactiveSeq.of(b)))),acc,next);
+        BiFunction<AnyM2<W,Stream<T>,T2>,AnyM2<W,T,T2>,AnyM2<W,Stream<T>,T2>> combineToStream = (acc, next) -> (AnyM2)c.ap2(c.unit(Lambda.l2((Stream<T> a)->(T b)->ReactiveSeq.concat(a,ReactiveSeq.of(b)))),acc,next);
 
         BinaryOperator<AnyM2<W,Stream<T>,T2>> combineStreams = (a, b)-> (AnyM2<W,Stream<T>,T2>)a.zip(b,(z1, z2)->(Stream<T>)ReactiveSeq.concat(z1,z2)); // a.apply(b, (s1,s2)->s1);
 
diff --git a/src/main/java/cyclops/monads/Kleisli.java b/src/main/java/cyclops/monads/Kleisli.java
index f92f320b14..113cbd8eb7 100644
--- a/src/main/java/cyclops/monads/Kleisli.java
+++ b/src/main/java/cyclops/monads/Kleisli.java
@@ -16,7 +16,7 @@ public class Kleisli<T,R,W extends WitnessType<W>> implements Fn1<T,AnyM<W,R>>,
                                                                 Transformable<R>{
 
     public final Fn1<T, AnyM<W, R>> fn;
-    private final W type = null;
+    private final W type;
 
     @Override
     public AnyM<W,R> apply(T a) {
@@ -25,34 +25,34 @@ public AnyM<W,R> apply(T a) {
     }
 
     public <R1> Kleisli<T,R1,W> map(Function<? super R, ? extends R1> mapper){
-        return kleisli(fn.andThen(am->am.map(mapper)));
+        return kleisli(fn.andThen(am->am.map(mapper)),type);
     }
 
     public <R1> Kleisli<T,R1,W> flatMap(Function<? super R, ? extends AnyM<W,? extends R1>> mapper){
-        return kleisli(fn.andThen(am->am.flatMapA(mapper)));
+        return kleisli(fn.andThen(am->am.flatMapA(mapper)),type);
     }
 
     public <A> Kleisli<A,R,W> compose(Kleisli<A,T,W> kleisli) {
-        return new Kleisli<A,R,W>(a -> kleisli.apply(a).flatMapA(this));
+        return new Kleisli<A,R,W>(a -> kleisli.apply(a).flatMapA(this),type);
     }
     public <R2> Kleisli<T,R2,W> then(Kleisli<R,R2,W> kleisli) {
 
         return new Kleisli<T,R2,W>(t->this.apply(t)
-                                    .flatMapA(kleisli));
+                                    .flatMapA(kleisli),type);
 
     }
 
     public <__> Kleisli<Xor<T, __>, Xor<R, __>,W> leftK() {
-         return kleisli(xr -> xr.visit(l -> fn.apply(l).map(Xor::secondary), r -> type.adapter().unit(r).map(Xor::primary)));
+         return kleisli(xr -> xr.visit(l -> fn.apply(l).map(Xor::secondary), r -> type.adapter().unit(r).map(Xor::primary)),type);
     }
     public <__> Kleisli<Xor<__,T>, Xor<__,R>,W> rightK() {
-        return kleisli(xr -> xr.visit(l -> type.adapter().unit(l).map(Xor::secondary), r -> fn.apply(r).map(Xor::primary)));
+        return kleisli(xr -> xr.visit(l -> type.adapter().unit(l).map(Xor::secondary), r -> fn.apply(r).map(Xor::primary)),type);
     }
     public <__> Kleisli<Tuple2<T, __>, Tuple2<R, __>,W> firstK() {
-        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v1).map(r1-> Tuple.tuple(r1,v2))));
+        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v1).map(r1-> Tuple.tuple(r1,v2))),type);
     }
     public <__> Kleisli<Tuple2<__,T>, Tuple2<__,R>,W> secondK() {
-        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v2).map(r2-> Tuple.tuple(v1,r2))));
+        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v2).map(r2-> Tuple.tuple(v1,r2))),type);
     }
 
 
@@ -64,16 +64,16 @@ public <T2,R2> Kleisli<Xor<T, T2>, Xor<R, R2>,W> merge(Kleisli<T2,R2,W> merge, W
     }
 
     public <T2> Kleisli<Xor<T, T2>, R,W> fanIn(Kleisli<T2,R,W> fanIn) {
-        return new Kleisli<>(e -> e.visit(this, fanIn));
+        return new Kleisli<>(e -> e.visit(this, fanIn),type);
     }
 
 
 
-    public static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> kleisli(Function<? super T,? extends AnyM<W,? extends R>> fn){
-        return new Kleisli<T, R, W>(narrow(fn));
+    public static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> kleisli(Function<? super T,? extends AnyM<W,? extends R>> fn, W type){
+        return new Kleisli<T, R, W>(narrow(fn),type);
     }
     public static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> lift(Function<? super T,? extends R> fn, W type){
-        return  kleisli(fn.andThen(r->type.adapter().unit(r)));
+        return  kleisli(fn.andThen(r->type.adapter().unit(r)),type);
     }
 
     private static <T, W extends WitnessType<W>, R> Fn1<T,AnyM<W,R>> narrow(Function<? super T, ? extends AnyM<W, ? extends R>> fn) {
diff --git a/src/test/java/com/aol/cyclops2/control/Xor2Test.java b/src/test/java/com/aol/cyclops2/control/Xor2Test.java
index aa5405ff09..b6a07ff706 100644
--- a/src/test/java/com/aol/cyclops2/control/Xor2Test.java
+++ b/src/test/java/com/aol/cyclops2/control/Xor2Test.java
@@ -101,8 +101,8 @@ public void visit(){
 	}
 	@Test
     public void visitXor(){
-        assertThat(just.mapBoth(secondary->"no", primary->"yes"),equalTo(Xor.primary("yes")));
-        assertThat(none.mapBoth(secondary->"no", primary->"yes"),equalTo(Xor.secondary("no")));
+        assertThat(just.bimap(secondary->"no", primary->"yes"),equalTo(Xor.primary("yes")));
+        assertThat(none.bimap(secondary->"no", primary->"yes"),equalTo(Xor.secondary("no")));
     }
 	@Test
 	public void testToMaybe() {
diff --git a/src/test/java/cyclops/control/StateTest.java b/src/test/java/cyclops/control/StateTest.java
new file mode 100644
index 0000000000..e2013f3a82
--- /dev/null
+++ b/src/test/java/cyclops/control/StateTest.java
@@ -0,0 +1,40 @@
+package cyclops.control;
+
+import org.jooq.lambda.tuple.Tuple;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.*;
+
+/**
+ * Created by johnmcclean on 04/02/2017.
+ */
+public class StateTest {
+
+    @Test
+    public void eval(){
+        State<String,Integer> state = State.state(s-> Tuple.tuple(s,10));
+        assertThat(state.eval("hello"),equalTo(10));
+    }
+    @Test
+    public void run(){
+        State<String,Integer> state = State.state(s-> Tuple.tuple(s,10));
+        assertThat(state.run("hello"),equalTo(Tuple.tuple("hello",10)));
+    }
+
+    @Test
+    public void map(){
+        State<String,Integer> state = State.<String,Integer>state(s-> Tuple.tuple(s,10))
+                                            .map(i->i*2);
+        assertThat(state.run("hello"),equalTo(Tuple.tuple("hello",20)));
+    }
+    @Test
+    public void flatMap(){
+        State<String,Integer> state = State.<String,Integer>state(s-> Tuple.tuple(s,10))
+                                            .flatMap(i->State.state(s->Tuple.tuple(s,i*2)));
+        assertThat(state.run("hello"),equalTo(Tuple.tuple("hello",20)));
+    }
+
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/cyclops/free/FreeTest.java b/src/test/java/cyclops/free/FreeTest.java
index fe0e7e4213..8b19d5cd2d 100644
--- a/src/test/java/cyclops/free/FreeTest.java
+++ b/src/test/java/cyclops/free/FreeTest.java
@@ -15,6 +15,7 @@ public final class FreeTest {
     private static Free<SupplierKind.µ, Long> fibonacci(long i){
         return fibonacci(i,1,0);
     }
+
     private static Free<SupplierKind.µ, Long> fibonacci(long n, long a, long b) {
         return n == 0 ? Free.done(b) : λK( ()->fibonacci(n-1, a+b, a))
                                         .kindTo(Fn0::suspend)

From dcea876015e4aec842baaecee7eabbad2e7fc3d6 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Sun, 5 Feb 2017 11:21:20 +0000
Subject: [PATCH 04/14] ReaderWriterState monad

---
 .../cyclops/control/ReaderWriterState.java    | 47 +++++++++++--------
 1 file changed, 27 insertions(+), 20 deletions(-)

diff --git a/src/main/java/cyclops/control/ReaderWriterState.java b/src/main/java/cyclops/control/ReaderWriterState.java
index dc8630a7b9..2accd03ad5 100644
--- a/src/main/java/cyclops/control/ReaderWriterState.java
+++ b/src/main/java/cyclops/control/ReaderWriterState.java
@@ -2,41 +2,48 @@
 
 import cyclops.free.Free;
 import cyclops.function.*;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
 import org.jooq.lambda.tuple.Tuple;
 import org.jooq.lambda.tuple.Tuple2;
+import org.jooq.lambda.tuple.Tuple3;
 
+import java.util.function.BiFunction;
 import java.util.function.Function;
 
-/**
- * Created by johnmcclean on 05/02/2017.
- */
-public class ReaderWriterState<R,W,S,T>  {
 
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class ReaderWriterState<R,W,S,T>  {
 
-    Reader<S, Free<Fn0.SupplierKind.µ,Tuple2<Writer<W, S>, T>>> runState;
+    Monoid<W> monoid;
+    BiFunction<R,S, Free<Fn0.SupplierKind.µ,Tuple3<W, S, T>>> runState;
 
-    public Tuple2<Writer<W,S>,T> run(S s) {
-        return Fn0.run(runState.apply(s));
+    public Tuple3<W,S,T> run(R r,S s) {
+        return Fn0.run(runState.apply(r,s));
     }
-    public T eval(S s) {
-        return Fn0.run(runState.apply(s)).v2;
-    }
-    public <R> State<S, R> map(Function<? super T,? extends R> mapper) {
-        return mapState(t -> Tuple.tuple(t.v1, mapper.apply(t.v2)));
+
+    public <R2> ReaderWriterState<R,W,S,R2> map(Function<? super T,? extends R2> mapper) {
+
+        return mapState(t -> Tuple.tuple(t.v1, t.v2, mapper.apply(t.v3)));
     }
-    public <R> State<S, R> mapState(Function<Tuple2<S,T>, Tuple2<S, R>> fn) {
-        return suspended(s -> runState.apply(s).map(t -> fn.apply(t.map((w,r)->w.getValue().map2(__->r)))));
+    public <R2> ReaderWriterState<R,W,S,R2> mapState(Function<Tuple3<W,S,T>, Tuple3<W,S, R2>> fn) {
+        return suspended((r,s) -> runState.apply(r,s).map(t3 -> fn.apply(t3)),monoid);
     }
-    private static <S, T> State<S, T> suspended(Fn1<? super S, Free<Fn0.SupplierKind.µ,Tuple2<S, T>>> runF) {
-        return new State<>(s -> Fn0.suspend(Lambda.λK(()->runF.apply(s))));
+    private static <R,W,S,T> ReaderWriterState<R,W,S,T> suspended(BiFunction<? super R, ? super S, Free<Fn0.SupplierKind.µ,Tuple3<W,S, T>>> runF,
+                                                                  Monoid<W> monoid) {
+
+        return new ReaderWriterState<R, W, S, T>(monoid,(R r ,S s) -> Fn0.suspend(Lambda.λK(()->runF.apply(r,s))));
+
     }
 
-    public <R> State<S, R> flatMap(Function<? super T,? extends  State<S, R>> f) {
-        return suspended(s -> runState.apply(s).flatMap(result -> Free.done(f.apply(result.v2).run(result.v1))));
+    public <R2> ReaderWriterState<R,W,S,R2> flatMap(Function<? super T,? extends  ReaderWriterState<R,W,S,R2>> f) {
+
+        return suspended((r,s) -> runState.apply(r, s)
+                .flatMap(result -> Free.done(f.apply(result.v3).run(r, result.v2))),monoid);
     }
 
-    public static <R,W,S,T> ReaderWriterState<R,W,S,T> rws(Function<? super S,? extends Tuple2<S, T>> runF, Monoid<W> monoid) {
+    public static <R,W,S,T> ReaderWriterState<R,W,S,T> rws(BiFunction<? super R, ? super S,? extends Tuple3<W,S, T>> runF, Monoid<W> monoid) {
 
-        return new State<>(s -> Free.done(runF.apply(s)));
+        return new ReaderWriterState<R, W, S, T>(monoid,(r,s) -> Free.done(runF.apply(r,s)));
     }
 }

From 60216adbfc1c8b32ae257a2e63cc16864613267f Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Sun, 5 Feb 2017 11:49:33 +0000
Subject: [PATCH 05/14] initial ReaderT

---
 src/main/java/cyclops/monads/AnyM2.java       |  10 +
 .../cyclops/monads/transformers/ReaderT.java  | 186 ++++++++++++++++++
 2 files changed, 196 insertions(+)
 create mode 100644 src/main/java/cyclops/monads/transformers/ReaderT.java

diff --git a/src/main/java/cyclops/monads/AnyM2.java b/src/main/java/cyclops/monads/AnyM2.java
index f8d3a7bf80..18726b8fde 100644
--- a/src/main/java/cyclops/monads/AnyM2.java
+++ b/src/main/java/cyclops/monads/AnyM2.java
@@ -668,4 +668,14 @@ default ListT<W, T> liftMListX() {
         return ListT.of(this.map(a -> ListX.of(a)));
     }
 
+    /**
+     * Fluent api for type conversion
+     *
+     * @param reduce Funtion to convert this type
+     * @return Converted type
+     */
+    default <R> R to2(Function<? super AnyM2<W,T,T2>,? extends R> reduce){
+        return reduce.apply(this);
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/cyclops/monads/transformers/ReaderT.java b/src/main/java/cyclops/monads/transformers/ReaderT.java
new file mode 100644
index 0000000000..f689537374
--- /dev/null
+++ b/src/main/java/cyclops/monads/transformers/ReaderT.java
@@ -0,0 +1,186 @@
+package cyclops.monads.transformers;
+
+import com.aol.cyclops2.types.*;
+import com.aol.cyclops2.types.anyM.transformers.ValueTransformer;
+import cyclops.async.Future;
+import cyclops.control.Trampoline;
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Reader;
+import cyclops.monads.AnyM;
+import cyclops.monads.AnyM2;
+import cyclops.monads.WitnessType;
+import cyclops.stream.ReactiveSeq;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
+import org.jooq.lambda.tuple.Tuple3;
+import org.jooq.lambda.tuple.Tuple4;
+import org.reactivestreams.Publisher;
+
+import java.util.Iterator;
+import java.util.concurrent.Executor;
+import java.util.function.*;
+import java.util.stream.Stream;
+
+/**
+* Monad Transformer for Future's nested within another monadic type
+
+ * 
+ * FutureT allows the deeply wrapped Future to be manipulating within it's nested /contained context
+ *
+ * @author johnmcclean
+ *
+ * @param <T> Type of data stored inside the nested Future(s)
+ */
+public final class ReaderT<W extends WitnessType<W>,T,R>  implements  To<ReaderT<W,T,R>>,
+        Transformable<R>{
+
+    private final AnyM2<W,Reader<T,R>,T> run;
+
+
+
+
+
+    /**
+     * @return The wrapped AnyM
+     */
+
+    public AnyM2<W,Reader<T,R>,T> unwrap() {
+        return run;
+    }
+
+    public <R2> R2 unwrapTo(Function<? super AnyM2<W,Reader<T,R>,T>, ? extends R2> fn) {
+        return unwrap().to2(fn);
+    }
+
+    private ReaderT(final AnyM2<W,Reader<T,R>,T> run) {
+        this.run = run;
+    }
+
+    
+
+
+
+    /**
+     * Peek at the current value of the Future
+     * <pre>
+     * {@code 
+     *    FutureWT.of(AnyM.fromStream(Arrays.asFutureW(10))
+     *             .peek(System.out::println);
+     *             
+     *     //prints 10        
+     * }
+     * </pre>
+     * 
+     * @param peek  Consumer to accept current value of Future
+     * @return FutureWT with peek call
+     */
+    @Override
+    public ReaderT<W,T,R> peek(final Consumer<? super R> peek) {
+        return of(run.peek(reader -> reader.map(a -> {
+            peek.accept(a);
+            return a;
+        })));
+    }
+
+    /**
+     * Map the wrapped Future
+     * 
+     * <pre>
+     * {@code 
+     *  FutureWT.of(AnyM.fromStream(Arrays.asFutureW(10))
+     *             .map(t->t=t+1);
+     *  
+     *  
+     *  //FutureWT<AnyMSeq<Stream<Future[11]>>>
+     * }
+     * </pre>
+     * 
+     * @param f Mapping function for the wrapped Future
+     * @return FutureWT that applies the map function to the wrapped Future
+     */
+
+    public <B> ReaderT<W,T,B> map(final Function<? super R, ? extends B> f) {
+        return new ReaderT<W,T,B>(
+                                  run.map(o -> o.map(f)));
+    }
+
+
+    public <B> ReaderT<W, T, B> flatMap(final Function<? super R, ? extends Reader<T, B>> f) {
+
+        return new ReaderT<W,T, B>(
+                run.map(o -> o.flatMap(f)));
+
+    }
+
+    public <B> ReaderT<W,T,B> flatMapT(final Function<? super R, ReaderT<W,T,B>> f) {
+        return of(run.map(reader-> reader.flatMap(a -> f.apply(a).run.unwrap())));
+    }
+
+
+
+
+
+
+
+
+    /**
+     * Construct an FutureWT from an AnyM that wraps a monad containing  FutureWs
+     * 
+     * @param monads AnyM that contains a monad wrapping an Future
+     * @return FutureWT
+     */
+    public static <W extends WitnessType<W>,T,R> ReaderT<W,T,R> of(final AnyM2<W,Reader<T,R>,T> monads) {
+        return new ReaderT<>(
+                                 monads);
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return String.format("ReaderT[%s]", run.unwrap().toString());
+    }
+
+    
+
+
+
+
+   
+    @Override
+    public int hashCode() {
+        return run.hashCode();
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (o instanceof ReaderT) {
+            return run.equals(((ReaderT) o).run);
+        }
+        return false;
+    }
+
+
+    public String mkString(){
+        return toString();
+    }
+
+    @Override
+    public <U> ReaderT<W,T,U> cast(Class<? extends U> type) {
+        return (ReaderT<W,T,U>)Transformable.super.cast(type);
+    }
+
+
+
+    @Override
+    public <R2> ReaderT<W,T,R2> trampoline(Function<? super R, ? extends Trampoline<? extends R2>> mapper) {
+        return (ReaderT<W,T,R2>)Transformable.super.trampoline(mapper);
+    }
+
+
+
+}
\ No newline at end of file

From 2d47c9e9bf8cb663bbab4a357cf9f8c149e08992 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Sun, 5 Feb 2017 11:52:22 +0000
Subject: [PATCH 06/14] use eager Xor rather than lazy Either?

---
 src/main/java/cyclops/function/Fn1.java | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/main/java/cyclops/function/Fn1.java b/src/main/java/cyclops/function/Fn1.java
index 7e5a547d54..2aec3931a7 100644
--- a/src/main/java/cyclops/function/Fn1.java
+++ b/src/main/java/cyclops/function/Fn1.java
@@ -5,7 +5,6 @@
 import java.util.function.Function;
 
 import cyclops.control.*;
-import cyclops.control.either.Either;
 import cyclops.monads.Kleisli;
 import cyclops.monads.transformers.FutureT;
 import cyclops.monads.transformers.ListT;
@@ -67,8 +66,8 @@ default Fn1<T1,R> memoize(Cacheable<R> c){
     }
 
     default <T2,R2> Fn1<Xor<T1, T2>, Xor<R, R2>> merge(Function<? super T2, ? extends R2> fn) {
-        Fn1<T1, Xor<R, R2>> first = andThen(Either::left);
-        Function<? super T2, ? extends Xor<R,R2>> second = fn.andThen(Either::right);
+        Fn1<T1, Xor<R, R2>> first = andThen(Xor::secondary);
+        Function<? super T2, ? extends Xor<R,R2>> second = fn.andThen(Xor::primary);
         return first.fanIn(second);
 
     }
@@ -78,11 +77,11 @@ default <T2> Fn1<Xor<T1, T2>, R> fanIn(Function<? super T2, ? extends R> fanIn)
     }
     default <__> Fn1<Xor<T1, __>, Xor<R, __>> leftFn() {
 
-        return either ->  either.bimap(this,Function.identity());
+        return either->  either.bimap(this,Function.identity());
     }
     default <__> Fn1<Xor<__,T1>, Xor<__,R>> rightFn() {
 
-        return either ->  either.bimap(Function.identity(),this);
+        return either->  either.bimap(Function.identity(),this);
     }
 
 

From 3ca8d711e11476683153dcc1adf06d60c5d3a597 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Mon, 6 Feb 2017 12:40:24 +0000
Subject: [PATCH 07/14] better Kleisli flatMap impl and for comprehensions

---
 src/main/java/cyclops/free/Free.java          |   4 +-
 src/main/java/cyclops/function/Reader.java    | 122 +++---------------
 src/main/java/cyclops/monads/AnyM2.java       |   1 -
 src/main/java/cyclops/monads/Kleisli.java     | 121 ++++++++++++++---
 .../cyclops/monads/transformers/ReaderT.java  | 119 ++++++++++++++++-
 .../functions/fluent/reader/Application.java  |   5 +-
 .../functions/fluent/reader/DITest.java       |   8 ++
 src/test/java/cyclops/monads/KleisliTest.java |  39 ++++++
 8 files changed, 281 insertions(+), 138 deletions(-)
 create mode 100644 src/test/java/cyclops/monads/KleisliTest.java

diff --git a/src/main/java/cyclops/free/Free.java b/src/main/java/cyclops/free/Free.java
index b8aeffbea2..f2eb57ab46 100644
--- a/src/main/java/cyclops/free/Free.java
+++ b/src/main/java/cyclops/free/Free.java
@@ -18,8 +18,8 @@
 /**
  * Free monad for cyclops2
  *
- * Inspiration and influences by https://github.com/xuwei-k/free-monad-java/blob/master/src/main/java/free/Free.java
- * and http://www.slideshare.net/kenbot/running-free-with-the-monads
+ * Inspiration and heavily influenced by https://github.com/xuwei-k/free-monad-java/blob/master/src/main/java/free/Free.java
+ * Other influences incl :- http://www.slideshare.net/kenbot/running-free-with-the-monads
  * and https://github.com/scalaz/scalaz/blob/series/7.2.x/core/src/main/scala/scalaz/Free.scala
  * and https://github.com/typelevel/cats/blob/master/free/src/main/scala/cats/free/Free.scala
  *
diff --git a/src/main/java/cyclops/function/Reader.java b/src/main/java/cyclops/function/Reader.java
index 3d7ab0fcca..b2a49e7a14 100644
--- a/src/main/java/cyclops/function/Reader.java
+++ b/src/main/java/cyclops/function/Reader.java
@@ -13,31 +13,7 @@
  * 
  * {@see <a href="https://medium.com/@johnmcclean/dependency-injection-using-the-reader-monad-in-java8-9056d9501c75">Dependency injection using the Reader Monad in Java 8</a>}
  * 
- * <pre>
- * {@code 
- * For comprehension with the Reader Monad, using curried syntax :-
- *  
- * import com.aol.cyclops2.control.For;
- * 
- * Reader<UserRepository,Integer> res =  For.reader(depth1("bob"))
-                                            .reader(a->depth2("bob"))
-                                            .reader(a->b->depth3("bob"))
-                                            .reader(a->b->c->depth3("bob"))
-                                            .reader(a->b->c->d->depth4("bob"))
-                                            .reader(a->b->c->d->e->depth5("bob"))
-                                            .reader(a->b->c->d->e->f->depth5("bob"))
-                                            .reader(a->b->c->d->e->f->g->depth6("bob"))
-                                            .yield(a->b->c->d->e->f->g->h->a+b+c+d+e+f+g+h).unwrap();
-   res.apply(new UserRepositoryImpl())
-   //29
-   private Reader<UserRepository,Integer> depth8(String name){
-        return repo->depth7(name).apply(repo)+1;
-   }
- * 
- * 
- * }
- * </pre>
- * 
+ *
  * 
  * @author johnmcclean
  *
@@ -65,45 +41,21 @@ default <R1> Reader<T, R1> flatMap(final Function<? super R, ? extends Reader<T,
                                         .apply(a));
     }
 
-   /*
-    * Perform a For Comprehension over a Reader, accepting 3 generating function.
-            * This results in a four level nested internal iteration over the provided Readers.
-     *
-             *  <pre>
-     * {@code
-     *
-     *   import static com.aol.cyclops2.reactor.Readers.forEach4;
-     *
-        forEach4(Reader.just(1),
-                a-> Reader.just(a+1),
-                (a,b) -> Reader.<Integer>just(a+b),
-                a                  (a,b,c) -> Reader.<Integer>just(a+b+c),
-                Tuple::tuple)
-     *
-     * }
-     * </pre>
-            *
-            * @param value1 top level Reader
-     * @param value2 Nested Reader
-     * @param value3 Nested Reader
-     * @param value4 Nested Reader
-     * @param yieldingFunction Generates a result per combination
-     * @return Reader with a combined value generated by the yielding function
-     */
-    default <R1, R2, R3, R4> Reader<T,R4> forEach4(Function<? super R, ? extends Reader<T,R1>> value2,
-                                                                 BiFunction<? super R, ? super R1, ? extends Reader<T,R2>> value3,
-                                                                 Fn3<? super R, ? super R1, ? super R2, ? extends Reader<T,R3>> value4,
+
+    default <R1, R2, R3, R4> Reader<T,R4> forEach4(Function<? super R, ? extends Function<T,R1>> value2,
+                                                                 BiFunction<? super R, ? super R1, ? extends Function<T,R2>> value3,
+                                                                 Fn3<? super R, ? super R1, ? super R2, ? extends Function<T,R3>> value4,
                                                                  Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
 
 
         return this.flatMap(in -> {
 
-            Reader<T,R1> a = value2.apply(in);
+            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
             return a.flatMap(ina -> {
-                Reader<T,R2> b = value3.apply(in,ina);
+                Reader<T,R2> b = FluentFunctions.of(value3.apply(in,ina));
                 return b.flatMap(inb -> {
 
-                    Reader<T,R3> c = value4.apply(in,ina,inb);
+                    Reader<T,R3> c = FluentFunctions.of(value4.apply(in,ina,inb));
 
                     return c.map(in2 -> {
 
@@ -123,38 +75,16 @@ default <R1, R2, R3, R4> Reader<T,R4> forEach4(Function<? super R, ? extends Rea
 
 
 
-    /**
-     * Perform a For Comprehension over a Reader, accepting 2 generating function.
-     * This results in a three level nested internal iteration over the provided Readers.
-     *
-     *  <pre>
-     * {@code
-     *
-     *   import static com.aol.cyclops2.reactor.Readers.forEach3;
-     *
-    forEach3(Reader.just(1),
-    a-> Reader.just(a+1),
-    (a,b) -> Reader.<Integer>just(a+b),
-    Tuple::tuple)
-     *
-     * }
-     * </pre>
-     *
-     * @param value1 top level Reader
-     * @param value2 Nested Reader
-     * @param value3 Nested Reader
-     * @param yieldingFunction Generates a result per combination
-     * @return Reader with a combined value generated by the yielding function
-     */
-    default <R1, R2, R4> Reader<T,R4> forEach3(Function<? super R, ? extends Reader<T,R1>> value2,
-                                                         BiFunction<? super R, ? super R1, ? extends Reader<T,R2>> value3,
+
+    default <R1, R2, R4> Reader<T,R4> forEach3(Function<? super R, ? extends Function<T,R1>> value2,
+                                                         BiFunction<? super R, ? super R1, ? extends Function<T,R2>> value3,
                                                          Fn3<? super R, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
 
         return this.flatMap(in -> {
 
-            Reader<T,R1> a = value2.apply(in);
+            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
             return a.flatMap(ina -> {
-                Reader<T,R2> b = value3.apply(in,ina);
+                Reader<T,R2> b = FluentFunctions.of(value3.apply(in,ina));
                 return b.map(in2 -> {
                         return yieldingFunction.apply(in, ina, in2);
 
@@ -169,33 +99,13 @@ default <R1, R2, R4> Reader<T,R4> forEach3(Function<? super R, ? extends Reader<
     }
 
 
-    /**
-     * Perform a For Comprehension over a Reader, accepting a generating function.
-     * This results in a two level nested internal iteration over the provided Readers.
-     *
-     *  <pre>
-     * {@code
-     *
-     *   import static com.aol.cyclops2.reactor.Readers.forEach;
-     *
-    forEach(Reader.just(1),
-    a-> Reader.just(a+1),
-    Tuple::tuple)
-     *
-     * }
-     * </pre>
-     *
-     * @param value1 top level Reader
-     * @param value2 Nested Reader
-     * @param yieldingFunction Generates a result per combination
-     * @return Reader with a combined value generated by the yielding function
-     */
-    default <R1, R4> Reader<T,R4> forEach2(Function<? super R, Reader<T,R1>> value2,
+
+    default <R1, R4> Reader<T,R4> forEach2(Function<? super R, Function<T,R1>> value2,
                                                 BiFunction<? super R, ? super R1, ? extends R4> yieldingFunction) {
 
         return this.flatMap(in -> {
 
-            Reader<T,R1> a = value2.apply(in);
+            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
             return a.map(in2 -> {
                     return yieldingFunction.apply(in, in2);
 
diff --git a/src/main/java/cyclops/monads/AnyM2.java b/src/main/java/cyclops/monads/AnyM2.java
index 18726b8fde..933ada758a 100644
--- a/src/main/java/cyclops/monads/AnyM2.java
+++ b/src/main/java/cyclops/monads/AnyM2.java
@@ -70,7 +70,6 @@
  */
 public interface AnyM2<W extends WitnessType<W>,T,T2> extends   AnyM<W,T>,
                                                                 Unwrapable,
-                                                              //  To<AnyM2<W,T,T2>>,
                                                                 EmptyUnit<T>,
                                                                 Unit<T>,
                                                                 Folds<T>,
diff --git a/src/main/java/cyclops/monads/Kleisli.java b/src/main/java/cyclops/monads/Kleisli.java
index 113cbd8eb7..a1ccd0d8b9 100644
--- a/src/main/java/cyclops/monads/Kleisli.java
+++ b/src/main/java/cyclops/monads/Kleisli.java
@@ -3,16 +3,19 @@
 
 import com.aol.cyclops2.types.Transformable;
 import cyclops.control.Xor;
-import cyclops.function.Fn1;
+import cyclops.function.*;
+import cyclops.monads.transformers.ReaderT;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import org.jooq.lambda.tuple.Tuple;
 import org.jooq.lambda.tuple.Tuple2;
 
+import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.stream.Stream;
 
 @AllArgsConstructor(access= AccessLevel.PRIVATE)
-public class Kleisli<T,R,W extends WitnessType<W>> implements Fn1<T,AnyM<W,R>>,
+public class Kleisli<W extends WitnessType<W>,T,R> implements Fn1<T,AnyM<W,R>>,
                                                                 Transformable<R>{
 
     public final Fn1<T, AnyM<W, R>> fn;
@@ -24,55 +27,133 @@ public AnyM<W,R> apply(T a) {
         return fn.apply(a);
     }
 
-    public <R1> Kleisli<T,R1,W> map(Function<? super R, ? extends R1> mapper){
+    public <R1> Kleisli<W,T,R1> map(Function<? super R, ? extends R1> mapper){
         return kleisli(fn.andThen(am->am.map(mapper)),type);
     }
-
-    public <R1> Kleisli<T,R1,W> flatMap(Function<? super R, ? extends AnyM<W,? extends R1>> mapper){
+    public <R1> Kleisli<W,T,R1> flatMapA(Function<? super R, ? extends AnyM<W,? extends R1>> mapper){
         return kleisli(fn.andThen(am->am.flatMapA(mapper)),type);
     }
+    public <R1> Kleisli<W,T,R1> flatMap(Function<? super R, ? extends Kleisli<W,T, R1>> mapper){
+        return kleisli(t->fn.apply(t).flatMapA(r ->  mapper.apply(r).fn.apply(t)),type);
+    }
 
-    public <A> Kleisli<A,R,W> compose(Kleisli<A,T,W> kleisli) {
-        return new Kleisli<A,R,W>(a -> kleisli.apply(a).flatMapA(this),type);
+    public <A> Kleisli<W,A,R> compose(Kleisli<W,A,T> kleisli) {
+        return new Kleisli<W,A,R>(a -> kleisli.apply(a).flatMapA(this),type);
     }
-    public <R2> Kleisli<T,R2,W> then(Kleisli<R,R2,W> kleisli) {
+    public <R2> Kleisli<W,T,R2> then(Kleisli<W,R,R2> kleisli) {
 
-        return new Kleisli<T,R2,W>(t->this.apply(t)
+        return new Kleisli<W,T,R2>(t->this.apply(t)
                                     .flatMapA(kleisli),type);
 
     }
 
-    public <__> Kleisli<Xor<T, __>, Xor<R, __>,W> leftK() {
+    public <__> Kleisli<W,Xor<T, __>, Xor<R, __>> leftK() {
          return kleisli(xr -> xr.visit(l -> fn.apply(l).map(Xor::secondary), r -> type.adapter().unit(r).map(Xor::primary)),type);
     }
-    public <__> Kleisli<Xor<__,T>, Xor<__,R>,W> rightK() {
+    public <__> Kleisli<W,Xor<__,T>, Xor<__,R>> rightK() {
         return kleisli(xr -> xr.visit(l -> type.adapter().unit(l).map(Xor::secondary), r -> fn.apply(r).map(Xor::primary)),type);
     }
-    public <__> Kleisli<Tuple2<T, __>, Tuple2<R, __>,W> firstK() {
+    public <__> Kleisli<W,Tuple2<T, __>, Tuple2<R, __>> firstK() {
         return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v1).map(r1-> Tuple.tuple(r1,v2))),type);
     }
-    public <__> Kleisli<Tuple2<__,T>, Tuple2<__,R>,W> secondK() {
+    public <__> Kleisli<W,Tuple2<__,T>, Tuple2<__,R>> secondK() {
         return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v2).map(r2-> Tuple.tuple(v1,r2))),type);
     }
 
 
-    public <T2,R2> Kleisli<Xor<T, T2>, Xor<R, R2>,W> merge(Kleisli<T2,R2,W> merge, W type) {
-        Kleisli<T, Xor<R, R2>, W> first = then(lift(Xor::secondary, type));
-        Kleisli<T2, Xor<R, R2>, W> second = merge.then(lift(Xor::primary, type));
+    public <T2,R2> Kleisli<W,Xor<T, T2>, Xor<R, R2>> merge(Kleisli<W,T2,R2> merge, W type) {
+        Kleisli<W,T, Xor<R, R2>> first = then(lift(Xor::secondary, type));
+        Kleisli<W,T2, Xor<R, R2>> second = merge.then(lift(Xor::primary, type));
         return first.fanIn(second);
 
     }
 
-    public <T2> Kleisli<Xor<T, T2>, R,W> fanIn(Kleisli<T2,R,W> fanIn) {
+    public <T2> Kleisli<W,Xor<T, T2>, R> fanIn(Kleisli<W,T2,R> fanIn) {
         return new Kleisli<>(e -> e.visit(this, fanIn),type);
     }
 
 
 
-    public static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> kleisli(Function<? super T,? extends AnyM<W,? extends R>> fn, W type){
-        return new Kleisli<T, R, W>(narrow(fn),type);
+    public <R1, R2, R3, R4> Kleisli<W,T,R4> forEach4(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
+                                                     BiFunction<? super R, ? super R1, Function<? super T,? extends AnyM<W,? extends R2>>> value3,
+                                                     Fn3<? super R, ? super R1, ? super R2, Function<? super T,? extends AnyM<W,? extends R3>>> value4,
+                                                    Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
+
+
+
+        Kleisli<W, T, R4> d2 = kleisli(t -> type.adapter().unit(yieldingFunction.apply(null, null, null, null)), type);
+
+        return this.flatMap(in -> {
+
+            Kleisli<W,T,R1> a = kleisli(value2.apply(in),type);
+            return a.flatMap(ina -> {
+                Kleisli<W,T,R2> b = kleisli(value3.apply(in,ina),type);
+                return b.flatMap(inb -> {
+
+                    Kleisli<W,T,R3> c = kleisli(value4.apply(in,ina,inb),type);
+                    return c.map(inc->yieldingFunction.apply(in, ina, inb, inc));
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+
+
+
+
+    public <R1, R2, R4> Kleisli<W,T,R4> forEach3(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
+                                               BiFunction<? super R, ? super R1, Function<? super T,? extends AnyM<W,? extends R2>>> value3,
+                                               Fn3<? super R, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            Kleisli<W,T,R1> a = kleisli(value2.apply(in),type);
+            return a.flatMap(ina -> {
+                Kleisli<W,T,R2> b = kleisli(value3.apply(in,ina),type);
+                return b.map(in2 -> {
+                    return yieldingFunction.apply(in, ina, in2);
+
+                });
+
+
+
+            });
+
+        });
+
+    }
+
+
+
+    public <R1, R4> Kleisli<W,T,R4> forEach2(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
+                                           BiFunction<? super R, ? super R1, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            Kleisli<W,T,R1> a = kleisli(value2.apply(in),type);
+            return a.map(in2 -> {
+                return yieldingFunction.apply(in, in2);
+
+            });
+
+
+
+
+        });
+
+
+    }
+
+
+    public static <T,R,W extends WitnessType<W>> Kleisli<W,T,R> kleisli(Function<? super T,? extends AnyM<W,? extends R>> fn, W type){
+        return new Kleisli<W,T, R>(narrow(fn),type);
     }
-    public static <T,R,W extends WitnessType<W>> Kleisli<T,R,W> lift(Function<? super T,? extends R> fn, W type){
+    public static <T,R,W extends WitnessType<W>> Kleisli<W,T,R> lift(Function<? super T,? extends R> fn, W type){
         return  kleisli(fn.andThen(r->type.adapter().unit(r)),type);
     }
 
diff --git a/src/main/java/cyclops/monads/transformers/ReaderT.java b/src/main/java/cyclops/monads/transformers/ReaderT.java
index f689537374..e8f19a07ae 100644
--- a/src/main/java/cyclops/monads/transformers/ReaderT.java
+++ b/src/main/java/cyclops/monads/transformers/ReaderT.java
@@ -4,9 +4,7 @@
 import com.aol.cyclops2.types.anyM.transformers.ValueTransformer;
 import cyclops.async.Future;
 import cyclops.control.Trampoline;
-import cyclops.function.Fn3;
-import cyclops.function.Fn4;
-import cyclops.function.Reader;
+import cyclops.function.*;
 import cyclops.monads.AnyM;
 import cyclops.monads.AnyM2;
 import cyclops.monads.WitnessType;
@@ -33,7 +31,7 @@
  * @param <T> Type of data stored inside the nested Future(s)
  */
 public final class ReaderT<W extends WitnessType<W>,T,R>  implements  To<ReaderT<W,T,R>>,
-        Transformable<R>{
+                                                                      Transformable<R>, Fn1<T,R> {
 
     private final AnyM2<W,Reader<T,R>,T> run;
 
@@ -105,7 +103,6 @@ public <B> ReaderT<W,T,B> map(final Function<? super R, ? extends B> f) {
                                   run.map(o -> o.map(f)));
     }
 
-
     public <B> ReaderT<W, T, B> flatMap(final Function<? super R, ? extends Reader<T, B>> f) {
 
         return new ReaderT<W,T, B>(
@@ -145,10 +142,115 @@ public String toString() {
         return String.format("ReaderT[%s]", run.unwrap().toString());
     }
 
-    
+
+    public <T2, R1, R2, R3, B> ReaderT<W,T,B> forEach4M(Function<? super R, ? extends ReaderT<W,T,R1>> value1,
+                                                      BiFunction<? super R, ? super R1, ? extends ReaderT<W,T,R2>> value2,
+                                                      Fn3<? super R, ? super R1, ? super R2, ? extends ReaderT<W,T,R3>> value3,
+                                                      Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends B> yieldingFunction) {
+        return this.flatMapT(in->value1.apply(in)
+                .flatMapT(in2-> value2.apply(in,in2)
+                        .flatMapT(in3->value3.apply(in,in2,in3)
+                                .map(in4->yieldingFunction.apply(in,in2,in3,in4)))));
+
+    }
+
+
+    public <T2, R1, R2, B> ReaderT<W,T,B> forEach3M(Function<? super R, ? extends ReaderT<W,T,R1>> value1,
+                                                  BiFunction<? super R, ? super R1, ? extends ReaderT<W,T,R2>> value2,
+                                                  Fn3<? super R, ? super R1, ? super R2, ? extends B> yieldingFunction) {
+
+        return this.flatMapT(in->value1.apply(in).flatMapT(in2-> value2.apply(in,in2)
+                .map(in3->yieldingFunction.apply(in,in2,in3))));
+
+    }
+
+
+    public <R1, B> ReaderT<W,T,B> forEach2M(Function<? super R, ? extends ReaderT<W,T,R1>> value1,
+                                          BiFunction<? super R, ? super R1, ? extends B> yieldingFunction) {
+
+
+        return this.flatMapT(in->value1.apply(in)
+                .map(in2->yieldingFunction.apply(in,in2)));
+    }
+
+
+    public <R1, R2, R3, R4> ReaderT<W,T,R4> forEach4(Function<? super R, ? extends Function<T,R1>> value2,
+                                                   BiFunction<? super R, ? super R1, ? extends Function<T,R2>> value3,
+                                                   Fn3<? super R, ? super R1, ? super R2, ? extends Function<T,R3>> value4,
+                                                   Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
+
+
+        return this.flatMap(in -> {
+
+            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
+            return a.flatMap(ina -> {
+                Reader<T,R2> b = FluentFunctions.of(value3.apply(in,ina));
+                return b.flatMap(inb -> {
+
+                    Reader<T,R3> c = FluentFunctions.of(value4.apply(in,ina,inb));
+
+                    return c.map(in2 -> {
+
+                        return yieldingFunction.apply(in, ina, inb, in2);
+
+                    });
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+
+
+
+
+    public <R1, R2, R4> ReaderT<W,T,R4> forEach3(Function<? super R, ? extends Function<T,R1>> value2,
+                                               BiFunction<? super R, ? super R1, ? extends Function<T,R2>> value3,
+                                               Fn3<? super R, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
+            return a.flatMap(ina -> {
+                Reader<T,R2> b = FluentFunctions.of(value3.apply(in,ina));
+                return b.map(in2 -> {
+                    return yieldingFunction.apply(in, ina, in2);
+
+                });
+
+
+
+            });
+
+        });
+
+    }
 
 
 
+    public <R1, R4> ReaderT<W,T,R4> forEach2(Function<? super R, Function<T,R1>> value2,
+                                           BiFunction<? super R, ? super R1, ? extends R4> yieldingFunction) {
+
+        return this.flatMap(in -> {
+
+            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
+            return a.map(in2 -> {
+                return yieldingFunction.apply(in, in2);
+
+            });
+
+
+
+
+        });
+
+
+    }
+
 
    
     @Override
@@ -182,5 +284,8 @@ public <R2> ReaderT<W,T,R2> trampoline(Function<? super R, ? extends Trampoline<
     }
 
 
-
+    @Override
+    public R apply(T a) {
+        return run.firstValue().apply(a);
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/aol/cyclops2/functions/fluent/reader/Application.java b/src/test/java/com/aol/cyclops2/functions/fluent/reader/Application.java
index 399ccc0a74..13393b2c80 100644
--- a/src/test/java/com/aol/cyclops2/functions/fluent/reader/Application.java
+++ b/src/test/java/com/aol/cyclops2/functions/fluent/reader/Application.java
@@ -3,14 +3,15 @@
 import java.util.Map;
 
 import cyclops.function.Reader;
-
+import org.junit.Test;
 
 
 public class Application {
 
 	UserRepositoryImpl repo = new UserRepositoryImpl();
 	
-	
+
+
 	public Map<String,String> userInfo(String username) {
 		return run(new UserInfo().userInfo(username));
 	 }
diff --git a/src/test/java/com/aol/cyclops2/functions/fluent/reader/DITest.java b/src/test/java/com/aol/cyclops2/functions/fluent/reader/DITest.java
index e0517ef96e..6b62ffd958 100644
--- a/src/test/java/com/aol/cyclops2/functions/fluent/reader/DITest.java
+++ b/src/test/java/com/aol/cyclops2/functions/fluent/reader/DITest.java
@@ -1,12 +1,17 @@
 package com.aol.cyclops2.functions.fluent.reader;
 
+import cyclops.async.Future;
+import cyclops.control.Maybe;
 import cyclops.function.FluentFunctions;
+import cyclops.function.Fn1;
 import cyclops.function.Reader;
 import com.aol.cyclops2.functions.fluent.reader.Application.UserRepositoryImpl;
 import org.junit.Test;
 
+import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.Function;
 
 import static org.hamcrest.Matchers.equalTo;
 import static org.junit.Assert.assertThat;
@@ -21,6 +26,9 @@ public class DITest {
 									put("email","bob@user.com");
 									put("boss","boss");
 								}};
+
+
+
 	@Test
 	public void test(){
 		assertThat(new Application().userInfo("bob"), equalTo(map));
diff --git a/src/test/java/cyclops/monads/KleisliTest.java b/src/test/java/cyclops/monads/KleisliTest.java
new file mode 100644
index 0000000000..f5af7e77e5
--- /dev/null
+++ b/src/test/java/cyclops/monads/KleisliTest.java
@@ -0,0 +1,39 @@
+package cyclops.monads;
+
+import org.junit.Test;
+
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by johnmcclean on 06/02/2017.
+ */
+public class KleisliTest {
+
+    @Test
+    public void flatMap(){
+        Kleisli<Witness.stream, Integer, Integer> k1 = Kleisli.kleisli(t -> AnyM.fromArray(1), Witness.stream.INSTANCE);
+
+        k1.flatMap(i->Kleisli.kleisli(t->AnyM.fromArray(i+t),Witness.stream.INSTANCE))
+                .apply(10)
+                .forEach(System.out::println);
+    }
+    @Test
+    public void flatMapA(){
+        Kleisli<Witness.stream, Integer, Integer> k1 = Kleisli.kleisli(t -> AnyM.fromArray(1), Witness.stream.INSTANCE);
+
+        k1.flatMapA(i->AnyM.fromArray(i+10))
+                .apply(10)
+                .forEach(System.out::println);
+    }
+    @Test
+    public void forTest(){
+        Kleisli<Witness.stream, Integer, Integer> k = Kleisli.kleisli(t -> AnyM.fromStream(Stream.of(t)), Witness.stream.INSTANCE);
+
+        k.forEach4(r->Kleisli.kleisli(t->AnyM.fromStream(Stream.of(t)),Witness.stream.INSTANCE),
+                                        (Integer r,Integer r1)->t->AnyM.fromArray(r,r1,t),
+                                        (r,r1,r2)->t->AnyM.fromArray(r),
+                                        (r,r1,r2,r3)-> r+r1);
+    }
+}
\ No newline at end of file

From 4c5b2e99b830a738462e897e770c0de74a131a7a Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Mon, 6 Feb 2017 12:59:45 +0000
Subject: [PATCH 08/14] add write to rws

---
 src/main/java/cyclops/control/ReaderWriterState.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/main/java/cyclops/control/ReaderWriterState.java b/src/main/java/cyclops/control/ReaderWriterState.java
index 2accd03ad5..d6caba7310 100644
--- a/src/main/java/cyclops/control/ReaderWriterState.java
+++ b/src/main/java/cyclops/control/ReaderWriterState.java
@@ -22,6 +22,11 @@ public Tuple3<W,S,T> run(R r,S s) {
         return Fn0.run(runState.apply(r,s));
     }
 
+    public  ReaderWriterState<R,W,S,T> write(W value) {
+        BiFunction<? super R, ? super S, Free<Fn0.SupplierKind.µ,Tuple3<W,S, T>>> fn = (r,s)->runState.apply(r,s).map(t3->Tuple.tuple(monoid.apply(t3.v1,value),t3.v2,t3.v3));
+        return suspended(fn,monoid);
+    }
+
     public <R2> ReaderWriterState<R,W,S,R2> map(Function<? super T,? extends R2> mapper) {
 
         return mapState(t -> Tuple.tuple(t.v1, t.v2, mapper.apply(t.v3)));
@@ -42,6 +47,8 @@ public <R2> ReaderWriterState<R,W,S,R2> flatMap(Function<? super T,? extends  Re
                 .flatMap(result -> Free.done(f.apply(result.v3).run(r, result.v2))),monoid);
     }
 
+
+
     public static <R,W,S,T> ReaderWriterState<R,W,S,T> rws(BiFunction<? super R, ? super S,? extends Tuple3<W,S, T>> runF, Monoid<W> monoid) {
 
         return new ReaderWriterState<R, W, S, T>(monoid,(r,s) -> Free.done(runF.apply(r,s)));

From 82f8eeb2ad2ac74f1f233ae8802c0b936c05b452 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Mon, 6 Feb 2017 15:19:57 +0000
Subject: [PATCH 09/14] wip

---
 .../java/cyclops/control/ReaderWriterState.java     | 13 ++++++++++++-
 src/main/java/cyclops/monads/Kleisli.java           | 12 ++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/main/java/cyclops/control/ReaderWriterState.java b/src/main/java/cyclops/control/ReaderWriterState.java
index d6caba7310..6fd06177f7 100644
--- a/src/main/java/cyclops/control/ReaderWriterState.java
+++ b/src/main/java/cyclops/control/ReaderWriterState.java
@@ -23,10 +23,21 @@ public Tuple3<W,S,T> run(R r,S s) {
     }
 
     public  ReaderWriterState<R,W,S,T> write(W value) {
-        BiFunction<? super R, ? super S, Free<Fn0.SupplierKind.µ,Tuple3<W,S, T>>> fn = (r,s)->runState.apply(r,s).map(t3->Tuple.tuple(monoid.apply(t3.v1,value),t3.v2,t3.v3));
+        BiFunction<? super R, ? super S, Free<Fn0.SupplierKind.µ,Tuple3<W,S, T>>> fn =
+                (r,s)->runState.apply(r,s).map(t3->Tuple.tuple(monoid.apply(t3.v1,value),t3.v2,t3.v3));
+
         return suspended(fn,monoid);
     }
 
+    public ReaderWriterState<R,W,S,T> ask() {
+         return suspended((r,s) -> runState.apply(r,s).map(t3 -> Tuple.<W,S,T>tuple(monoid.zero(),s,t3.v3)),monoid);
+    }
+
+
+    public ReaderWriterState<R,W,S,T> local(Function<? super  R,? extends R> fn) {
+        BiFunction<? super R, ? super S, Free<Fn0.SupplierKind.µ,Tuple3<W,S, T>>> runFn = (R r, S s) -> runState.apply(fn.apply(r), s);
+        return suspended(runFn,monoid);
+    }
     public <R2> ReaderWriterState<R,W,S,R2> map(Function<? super T,? extends R2> mapper) {
 
         return mapState(t -> Tuple.tuple(t.v1, t.v2, mapper.apply(t.v3)));
diff --git a/src/main/java/cyclops/monads/Kleisli.java b/src/main/java/cyclops/monads/Kleisli.java
index a1ccd0d8b9..65c84c7a02 100644
--- a/src/main/java/cyclops/monads/Kleisli.java
+++ b/src/main/java/cyclops/monads/Kleisli.java
@@ -14,6 +14,15 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+
+/**
+ * Compose functions that return monads
+ *
+ * @param <W> Monad kind
+ * @param <T> Function input type
+ * @param <R> Function return type
+ *              (inside monad e.g. Kleisli[stream,String,Integer] represents a function that takes a String and returns a Stream of Integers)
+ */
 @AllArgsConstructor(access= AccessLevel.PRIVATE)
 public class Kleisli<W extends WitnessType<W>,T,R> implements Fn1<T,AnyM<W,R>>,
                                                                 Transformable<R>{
@@ -27,6 +36,9 @@ public AnyM<W,R> apply(T a) {
         return fn.apply(a);
     }
 
+    public Kleisli<W,T,R> local(Function<? super R, ? extends R> local){
+        return kleisli(t->fn.apply(t).map(r->local.apply(r)),type);
+    }
     public <R1> Kleisli<W,T,R1> map(Function<? super R, ? extends R1> mapper){
         return kleisli(fn.andThen(am->am.map(mapper)),type);
     }

From c226e07956a37850e8af424b13b34b1e5193cd0d Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Mon, 6 Feb 2017 16:48:17 +0000
Subject: [PATCH 10/14] make Kleisli a functional interface

---
 .../cyclops/control/ReaderWriterState.java    |  10 +-
 src/main/java/cyclops/control/State.java      |   8 ++
 src/main/java/cyclops/control/Writer.java     |   3 +
 src/main/java/cyclops/function/AnyMFn1.java   |   3 +-
 src/main/java/cyclops/monads/Kleisli.java     | 129 +++++++++++-------
 src/main/java/cyclops/monads/Witness.java     |  11 +-
 src/test/java/cyclops/monads/KleisliTest.java |  24 +++-
 7 files changed, 125 insertions(+), 63 deletions(-)

diff --git a/src/main/java/cyclops/control/ReaderWriterState.java b/src/main/java/cyclops/control/ReaderWriterState.java
index 6fd06177f7..ebb532368e 100644
--- a/src/main/java/cyclops/control/ReaderWriterState.java
+++ b/src/main/java/cyclops/control/ReaderWriterState.java
@@ -15,6 +15,9 @@
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public class ReaderWriterState<R,W,S,T>  {
 
+    public static class µ {
+    }
+
     Monoid<W> monoid;
     BiFunction<R,S, Free<Fn0.SupplierKind.µ,Tuple3<W, S, T>>> runState;
 
@@ -38,6 +41,7 @@ public ReaderWriterState<R,W,S,T> local(Function<? super  R,? extends R> fn) {
         BiFunction<? super R, ? super S, Free<Fn0.SupplierKind.µ,Tuple3<W,S, T>>> runFn = (R r, S s) -> runState.apply(fn.apply(r), s);
         return suspended(runFn,monoid);
     }
+
     public <R2> ReaderWriterState<R,W,S,R2> map(Function<? super T,? extends R2> mapper) {
 
         return mapState(t -> Tuple.tuple(t.v1, t.v2, mapper.apply(t.v3)));
@@ -55,7 +59,11 @@ private static <R,W,S,T> ReaderWriterState<R,W,S,T> suspended(BiFunction<? super
     public <R2> ReaderWriterState<R,W,S,R2> flatMap(Function<? super T,? extends  ReaderWriterState<R,W,S,R2>> f) {
 
         return suspended((r,s) -> runState.apply(r, s)
-                .flatMap(result -> Free.done(f.apply(result.v3).run(r, result.v2))),monoid);
+                .flatMap(result -> Free.done(f.apply(result.v3)
+                                              .run(r, result.v2)
+                                              .map((w2,s2,r2)->Tuple.tuple(monoid.apply(w2,result.v1),s2,r2)
+
+                ))),monoid);
     }
 
 
diff --git a/src/main/java/cyclops/control/State.java b/src/main/java/cyclops/control/State.java
index e9008dae33..d45a83a1c2 100644
--- a/src/main/java/cyclops/control/State.java
+++ b/src/main/java/cyclops/control/State.java
@@ -13,6 +13,8 @@
 
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
 public final class State<S, T> {
+    public static class µ {
+    }
 
     private final Fn1<S, Free<Fn0.SupplierKind.µ,Tuple2<S, T>>> runState;
 
@@ -34,6 +36,9 @@ public static <S> State<S, Nothing> transition(Function<? super S,? extends S> f
     public static <S, T> State<S, T> transition(Function<? super S,? extends S> f, T value) {
         return state(s -> Tuple.tuple(f.apply(s),value));
     }
+    public <T2, R> State<S, R> combine(State<S, T2> combine, BiFunction<? super T, ? super T2, ? extends R> combiner) {
+        return flatMap(a -> combine.map(b -> combiner.apply(a,b)));
+    }
 
     public <R> State<S, R> map(Function<? super T,? extends R> mapper) {
         return mapState(t -> Tuple.tuple(t.v1, mapper.apply(t.v2)));
@@ -197,6 +202,9 @@ public static <S, T> State<S, T> state(Function<? super S,? extends Tuple2<S, T>
         return new State<>(s -> Free.done(runF.apply(s)));
     }
 
+    public static <S> State<S, Nothing> of(S s) {
+        return state(__ -> Tuple.tuple(s, (Nothing)Maybe.none()));
+    }
 
 
 
diff --git a/src/main/java/cyclops/control/Writer.java b/src/main/java/cyclops/control/Writer.java
index f626f1287e..10c5382b8a 100644
--- a/src/main/java/cyclops/control/Writer.java
+++ b/src/main/java/cyclops/control/Writer.java
@@ -21,6 +21,9 @@
 @Getter
 public final class Writer<W, T> implements Transformable<T>, Iterable<T> {
 
+    public static class µ {
+    }
+
     private final Tuple2<T,W> value;
     private final Monoid<W> monoid;
 
diff --git a/src/main/java/cyclops/function/AnyMFn1.java b/src/main/java/cyclops/function/AnyMFn1.java
index 03c36e7326..d90fabe4bd 100644
--- a/src/main/java/cyclops/function/AnyMFn1.java
+++ b/src/main/java/cyclops/function/AnyMFn1.java
@@ -1,12 +1,13 @@
 package cyclops.function;
 
 import cyclops.monads.AnyM;
+import cyclops.monads.Kleisli;
 import cyclops.monads.WitnessType;
 
 /**
  * Created by johnmcclean on 18/12/2016.
  */
 @FunctionalInterface
-public interface AnyMFn1<W extends WitnessType<W>,T1,R> extends Fn1<AnyM<W,T1>,AnyM<W,R>> {
+public interface AnyMFn1<W extends WitnessType<W>,T1,R> extends Kleisli<W,AnyM<W,T1>,R> {
 
 }
diff --git a/src/main/java/cyclops/monads/Kleisli.java b/src/main/java/cyclops/monads/Kleisli.java
index 65c84c7a02..caf1f55f92 100644
--- a/src/main/java/cyclops/monads/Kleisli.java
+++ b/src/main/java/cyclops/monads/Kleisli.java
@@ -23,86 +23,116 @@
  * @param <R> Function return type
  *              (inside monad e.g. Kleisli[stream,String,Integer] represents a function that takes a String and returns a Stream of Integers)
  */
-@AllArgsConstructor(access= AccessLevel.PRIVATE)
-public class Kleisli<W extends WitnessType<W>,T,R> implements Fn1<T,AnyM<W,R>>,
+@FunctionalInterface
+public interface Kleisli<W extends WitnessType<W>,T,R> extends Fn1<T,AnyM<W,R>>,
                                                                 Transformable<R>{
 
-    public final Fn1<T, AnyM<W, R>> fn;
-    private final W type;
-
-    @Override
-    public AnyM<W,R> apply(T a) {
-
-        return fn.apply(a);
+    static class µ {
     }
 
-    public Kleisli<W,T,R> local(Function<? super R, ? extends R> local){
-        return kleisli(t->fn.apply(t).map(r->local.apply(r)),type);
+    default Kleisli<W,T,R> local(Function<? super R, ? extends R> local){
+        return kleisli(t->apply(t).map(r->local.apply(r)));
     }
-    public <R1> Kleisli<W,T,R1> map(Function<? super R, ? extends R1> mapper){
-        return kleisli(fn.andThen(am->am.map(mapper)),type);
+    default <R1> Kleisli<W,T,R1> map(Function<? super R, ? extends R1> mapper){
+        return kleisli(andThen(am->am.map(mapper)));
     }
-    public <R1> Kleisli<W,T,R1> flatMapA(Function<? super R, ? extends AnyM<W,? extends R1>> mapper){
-        return kleisli(fn.andThen(am->am.flatMapA(mapper)),type);
+    default <R1> Kleisli<W,T,R1> flatMapA(Function<? super R, ? extends AnyM<W,? extends R1>> mapper){
+        return kleisli(andThen(am->am.flatMapA(mapper)));
     }
-    public <R1> Kleisli<W,T,R1> flatMap(Function<? super R, ? extends Kleisli<W,T, R1>> mapper){
-        return kleisli(t->fn.apply(t).flatMapA(r ->  mapper.apply(r).fn.apply(t)),type);
+
+    /**
+     *
+     * Compose functions that return monads.
+     *
+     * Example :-
+     *
+     * <pre>
+     *  {@code
+     *  import cyclops.monads.Witness.reactiveSeq;
+        import static cyclops.monads.Kleisli.kleisli;
+
+
+        Kleisli<reactiveSeq, Integer, Integer> k1 = kleisli(t -> ReactiveSeq.iterate(0,i->i<t, i->i+1)
+                                                                            .anyM(), reactiveSeq.INSTANCE);
+
+        k1.flatMap(i-> kleisli(t-> ReactiveSeq.of(t+i)
+                                              .anyM(), reactiveSeq.INSTANCE))
+          .apply(10)
+          .forEach(System.out::println);
+
+        10
+        11
+        12
+        13
+        14
+        15
+        16
+        17
+        18
+        19
+     *
+     * }</pre>
+     *
+     * @param mapper
+     * @param <R1>
+     * @return
+     */
+    default <R1> Kleisli<W,T,R1> flatMap(Function<? super R, ? extends Kleisli<W,T, R1>> mapper){
+        return kleisli(t->apply(t).flatMapA(r ->  mapper.apply(r).apply(t)));
     }
 
-    public <A> Kleisli<W,A,R> compose(Kleisli<W,A,T> kleisli) {
-        return new Kleisli<W,A,R>(a -> kleisli.apply(a).flatMapA(this),type);
+    default <A> Kleisli<W,A,R> compose(Kleisli<W,A,T> kleisli) {
+        return a -> kleisli.apply(a).flatMapA(this);
     }
-    public <R2> Kleisli<W,T,R2> then(Kleisli<W,R,R2> kleisli) {
+    default <R2> Kleisli<W,T,R2> then(Kleisli<W,R,R2> kleisli) {
 
-        return new Kleisli<W,T,R2>(t->this.apply(t)
-                                    .flatMapA(kleisli),type);
+        return t-> apply(t).flatMapA(kleisli);
 
     }
 
-    public <__> Kleisli<W,Xor<T, __>, Xor<R, __>> leftK() {
-         return kleisli(xr -> xr.visit(l -> fn.apply(l).map(Xor::secondary), r -> type.adapter().unit(r).map(Xor::primary)),type);
+    default <__> Kleisli<W,Xor<T, __>, Xor<R, __>> leftK(W type) {
+         return kleisli(xr -> xr.visit(l -> apply(l).map(Xor::secondary), r -> type.adapter().unit(r).map(Xor::primary)));
     }
-    public <__> Kleisli<W,Xor<__,T>, Xor<__,R>> rightK() {
-        return kleisli(xr -> xr.visit(l -> type.adapter().unit(l).map(Xor::secondary), r -> fn.apply(r).map(Xor::primary)),type);
+    default <__> Kleisli<W,Xor<__,T>, Xor<__,R>> rightK(W type) {
+        return kleisli(xr -> xr.visit(l -> type.adapter().unit(l).map(Xor::secondary), r -> apply(r).map(Xor::primary)));
     }
-    public <__> Kleisli<W,Tuple2<T, __>, Tuple2<R, __>> firstK() {
-        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v1).map(r1-> Tuple.tuple(r1,v2))),type);
+    default <__> Kleisli<W,Tuple2<T, __>, Tuple2<R, __>> firstK() {
+        return kleisli(xr -> xr.map((v1,v2) -> apply(v1).map(r1-> Tuple.tuple(r1,v2))));
     }
-    public <__> Kleisli<W,Tuple2<__,T>, Tuple2<__,R>> secondK() {
-        return kleisli(xr -> xr.map((v1,v2) -> fn.apply(v2).map(r2-> Tuple.tuple(v1,r2))),type);
+    default <__> Kleisli<W,Tuple2<__,T>, Tuple2<__,R>> secondK() {
+        return kleisli(xr -> xr.map((v1,v2) -> apply(v2).map(r2-> Tuple.tuple(v1,r2))));
     }
 
 
-    public <T2,R2> Kleisli<W,Xor<T, T2>, Xor<R, R2>> merge(Kleisli<W,T2,R2> merge, W type) {
+    default <T2,R2> Kleisli<W,Xor<T, T2>, Xor<R, R2>> merge(Kleisli<W,T2,R2> merge, W type) {
         Kleisli<W,T, Xor<R, R2>> first = then(lift(Xor::secondary, type));
         Kleisli<W,T2, Xor<R, R2>> second = merge.then(lift(Xor::primary, type));
         return first.fanIn(second);
 
     }
 
-    public <T2> Kleisli<W,Xor<T, T2>, R> fanIn(Kleisli<W,T2,R> fanIn) {
-        return new Kleisli<>(e -> e.visit(this, fanIn),type);
+    default <T2> Kleisli<W,Xor<T, T2>, R> fanIn(Kleisli<W,T2,R> fanIn) {
+        return e -> e.visit(this, fanIn);
     }
 
 
 
-    public <R1, R2, R3, R4> Kleisli<W,T,R4> forEach4(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
+    default <R1, R2, R3, R4> Kleisli<W,T,R4> forEach4(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
                                                      BiFunction<? super R, ? super R1, Function<? super T,? extends AnyM<W,? extends R2>>> value3,
                                                      Fn3<? super R, ? super R1, ? super R2, Function<? super T,? extends AnyM<W,? extends R3>>> value4,
                                                     Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
 
 
 
-        Kleisli<W, T, R4> d2 = kleisli(t -> type.adapter().unit(yieldingFunction.apply(null, null, null, null)), type);
 
         return this.flatMap(in -> {
 
-            Kleisli<W,T,R1> a = kleisli(value2.apply(in),type);
+            Kleisli<W,T,R1> a = kleisli(value2.apply(in));
             return a.flatMap(ina -> {
-                Kleisli<W,T,R2> b = kleisli(value3.apply(in,ina),type);
+                Kleisli<W,T,R2> b = kleisli(value3.apply(in,ina));
                 return b.flatMap(inb -> {
 
-                    Kleisli<W,T,R3> c = kleisli(value4.apply(in,ina,inb),type);
+                    Kleisli<W,T,R3> c = kleisli(value4.apply(in,ina,inb));
                     return c.map(inc->yieldingFunction.apply(in, ina, inb, inc));
 
                 });
@@ -118,15 +148,15 @@ public <R1, R2, R3, R4> Kleisli<W,T,R4> forEach4(Function<? super R, Function<?
 
 
 
-    public <R1, R2, R4> Kleisli<W,T,R4> forEach3(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
+    default <R1, R2, R4> Kleisli<W,T,R4> forEach3(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
                                                BiFunction<? super R, ? super R1, Function<? super T,? extends AnyM<W,? extends R2>>> value3,
                                                Fn3<? super R, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
 
         return this.flatMap(in -> {
 
-            Kleisli<W,T,R1> a = kleisli(value2.apply(in),type);
+            Kleisli<W,T,R1> a = kleisli(value2.apply(in));
             return a.flatMap(ina -> {
-                Kleisli<W,T,R2> b = kleisli(value3.apply(in,ina),type);
+                Kleisli<W,T,R2> b = kleisli(value3.apply(in,ina));
                 return b.map(in2 -> {
                     return yieldingFunction.apply(in, ina, in2);
 
@@ -140,14 +170,12 @@ public <R1, R2, R4> Kleisli<W,T,R4> forEach3(Function<? super R, Function<? supe
 
     }
 
-
-
-    public <R1, R4> Kleisli<W,T,R4> forEach2(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
+    default <R1, R4> Kleisli<W,T,R4> forEach2(Function<? super R, Function<? super T,? extends AnyM<W,? extends R1>>> value2,
                                            BiFunction<? super R, ? super R1, ? extends R4> yieldingFunction) {
 
         return this.flatMap(in -> {
 
-            Kleisli<W,T,R1> a = kleisli(value2.apply(in),type);
+            Kleisli<W,T,R1> a = kleisli(value2.apply(in));
             return a.map(in2 -> {
                 return yieldingFunction.apply(in, in2);
 
@@ -162,14 +190,17 @@ public <R1, R4> Kleisli<W,T,R4> forEach2(Function<? super R, Function<? super T,
     }
 
 
-    public static <T,R,W extends WitnessType<W>> Kleisli<W,T,R> kleisli(Function<? super T,? extends AnyM<W,? extends R>> fn, W type){
-        return new Kleisli<W,T, R>(narrow(fn),type);
+    public static <T,R,W extends WitnessType<W>> Kleisli<W,T,R> kleisli(Function<? super T,? extends AnyM<W,? extends R>> fn){
+        return in-> {
+            Fn1<T,AnyM<W,R>> fn1 = narrow(fn);
+            return fn1.apply(in);
+        };
     }
     public static <T,R,W extends WitnessType<W>> Kleisli<W,T,R> lift(Function<? super T,? extends R> fn, W type){
-        return  kleisli(fn.andThen(r->type.adapter().unit(r)),type);
+        return  kleisli(fn.andThen(r->type.adapter().unit(r)));
     }
 
-    private static <T, W extends WitnessType<W>, R> Fn1<T,AnyM<W,R>> narrow(Function<? super T, ? extends AnyM<W, ? extends R>> fn) {
+    static <T, W extends WitnessType<W>, R> Fn1<T,AnyM<W,R>> narrow(Function<? super T, ? extends AnyM<W, ? extends R>> fn) {
         if(fn instanceof Fn1){
             return (Fn1)fn;
         }
diff --git a/src/main/java/cyclops/monads/Witness.java b/src/main/java/cyclops/monads/Witness.java
index 821a4de2a1..c8531478bb 100644
--- a/src/main/java/cyclops/monads/Witness.java
+++ b/src/main/java/cyclops/monads/Witness.java
@@ -8,6 +8,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Stream;
 
+import com.aol.cyclops2.internal.comprehensions.comprehenders.*;
 import cyclops.control.Eval;
 import cyclops.async.Future;
 import cyclops.control.Ior;
@@ -28,12 +29,6 @@
 import cyclops.collections.QueueX;
 import cyclops.collections.SetX;
 import cyclops.collections.SortedSetX;
-import com.aol.cyclops2.internal.comprehensions.comprehenders.CollectionXAdapter;
-import com.aol.cyclops2.internal.comprehensions.comprehenders.FutureAdapter;
-import com.aol.cyclops2.internal.comprehensions.comprehenders.MonadicValueAdapter;
-import com.aol.cyclops2.internal.comprehensions.comprehenders.OptionalAdapter;
-import com.aol.cyclops2.internal.comprehensions.comprehenders.StreamAdapter;
-import com.aol.cyclops2.internal.comprehensions.comprehenders.StreamableAdapter;
 import com.aol.cyclops2.types.MonadicValue;
 import com.aol.cyclops2.types.extensability.FunctionalAdapter;
 
@@ -121,6 +116,8 @@ public static <ST,T> Ior<ST,T> ior(AnyM<ior,? extends T> anyM){
     public static <X extends Throwable,T> Try<T,X> Try(AnyM<tryType,? extends T> anyM){
         return anyM.unwrap();
     }
+
+
     public static enum stream implements StreamWitness<stream>{
         INSTANCE;
 
@@ -348,4 +345,4 @@ public FunctionalAdapter<optional> adapter() {
         }
         
     }
-}
+    }
diff --git a/src/test/java/cyclops/monads/KleisliTest.java b/src/test/java/cyclops/monads/KleisliTest.java
index f5af7e77e5..49a4045b60 100644
--- a/src/test/java/cyclops/monads/KleisliTest.java
+++ b/src/test/java/cyclops/monads/KleisliTest.java
@@ -1,9 +1,13 @@
 package cyclops.monads;
 
+import cyclops.monads.Witness.stream;
+import cyclops.monads.Witness.reactiveSeq;
+import cyclops.stream.ReactiveSeq;
 import org.junit.Test;
 
 import java.util.stream.Stream;
 
+import static cyclops.monads.Kleisli.kleisli;
 import static org.junit.Assert.*;
 
 /**
@@ -13,15 +17,25 @@ public class KleisliTest {
 
     @Test
     public void flatMap(){
-        Kleisli<Witness.stream, Integer, Integer> k1 = Kleisli.kleisli(t -> AnyM.fromArray(1), Witness.stream.INSTANCE);
+        Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(1);
 
-        k1.flatMap(i->Kleisli.kleisli(t->AnyM.fromArray(i+t),Witness.stream.INSTANCE))
+        k1.flatMap(i-> t->AnyM.fromArray(i+t))
+                .apply(10)
+                .forEach(System.out::println);
+    }
+    @Test
+    public void example(){
+        Kleisli<reactiveSeq, Integer, Integer> k1 = t -> ReactiveSeq.iterate(0,i->i<t, i->i+1)
+                                                                            .anyM();
+
+        k1.flatMap(i-> t-> ReactiveSeq.of(t+i)
+                                      .anyM())
                 .apply(10)
                 .forEach(System.out::println);
     }
     @Test
     public void flatMapA(){
-        Kleisli<Witness.stream, Integer, Integer> k1 = Kleisli.kleisli(t -> AnyM.fromArray(1), Witness.stream.INSTANCE);
+        Kleisli<stream, Integer, Integer> k1 =  t -> AnyM.fromArray(1);
 
         k1.flatMapA(i->AnyM.fromArray(i+10))
                 .apply(10)
@@ -29,9 +43,9 @@ public void flatMapA(){
     }
     @Test
     public void forTest(){
-        Kleisli<Witness.stream, Integer, Integer> k = Kleisli.kleisli(t -> AnyM.fromStream(Stream.of(t)), Witness.stream.INSTANCE);
+        Kleisli<stream, Integer, Integer> k = t -> AnyM.fromStream(Stream.of(t));
 
-        k.forEach4(r->Kleisli.kleisli(t->AnyM.fromStream(Stream.of(t)),Witness.stream.INSTANCE),
+        k.forEach4(r-> t->AnyM.fromStream(Stream.of(t)),
                                         (Integer r,Integer r1)->t->AnyM.fromArray(r,r1,t),
                                         (r,r1,r2)->t->AnyM.fromArray(r),
                                         (r,r1,r2,r3)-> r+r1);

From 5e6d4cf11ea260be2b2d1ee7c83d75ded0d5e47b Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Thu, 9 Feb 2017 21:31:45 +0000
Subject: [PATCH 11/14] add some tests

---
 src/jmh/java/scrabble/NonParallelStreams.java |  2 +-
 .../internal/stream/ReactiveStreamX.java      |  2 +-
 .../spliterators/IteratableSpliterator.java   |  4 +-
 .../spliterators/push/ZippingOperator.java    |  2 +-
 .../java/com/aol/cyclops2/types/Folds.java    |  4 +-
 .../types/futurestream/SimpleReactStream.java |  6 +-
 src/main/java/cyclops/Functions.java          | 55 ++++++++++--
 .../cyclops/control/ReaderWriterState.java    |  2 +-
 src/main/java/cyclops/control/Writer.java     |  6 +-
 src/main/java/cyclops/free/Free.java          | 38 ++++++++-
 .../java/cyclops/function/Predicates.java     | 57 +++++++++----
 src/main/java/cyclops/function/Reader.java    | 34 ++++----
 src/main/java/cyclops/stream/ReactiveSeq.java |  4 +-
 .../cyclops2/streams/BaseSequentialTest.java  | 10 +--
 src/test/java/cyclops/free/CharToy.java       |  6 +-
 src/test/java/cyclops/free/FreeTest.java      | 83 +++++++++++++++++--
 src/test/java/cyclops/monads/KleisliTest.java | 17 +++-
 17 files changed, 263 insertions(+), 69 deletions(-)

diff --git a/src/jmh/java/scrabble/NonParallelStreams.java b/src/jmh/java/scrabble/NonParallelStreams.java
index ae34c1fb76..3d33e83cac 100644
--- a/src/jmh/java/scrabble/NonParallelStreams.java
+++ b/src/jmh/java/scrabble/NonParallelStreams.java
@@ -14,7 +14,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
+ * along with this program; if not, tell to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 
diff --git a/src/main/java/com/aol/cyclops2/internal/stream/ReactiveStreamX.java b/src/main/java/com/aol/cyclops2/internal/stream/ReactiveStreamX.java
index c864276360..5fb6ebd662 100644
--- a/src/main/java/com/aol/cyclops2/internal/stream/ReactiveStreamX.java
+++ b/src/main/java/com/aol/cyclops2/internal/stream/ReactiveStreamX.java
@@ -1012,7 +1012,7 @@ public Topic<T> broadcast(){
 
                     if(wip.compareAndSet(false,true)){
                         try {
-                            //use the first consuming thread to write this Stream onto the Queue
+                            //use the first consuming thread to tell this Stream onto the Queue
                             s.request(1000-queue.size());
                         }finally {
                             wip.set(false);
diff --git a/src/main/java/com/aol/cyclops2/internal/stream/spliterators/IteratableSpliterator.java b/src/main/java/com/aol/cyclops2/internal/stream/spliterators/IteratableSpliterator.java
index b32cc93d9c..5ae5119b2d 100644
--- a/src/main/java/com/aol/cyclops2/internal/stream/spliterators/IteratableSpliterator.java
+++ b/src/main/java/com/aol/cyclops2/internal/stream/spliterators/IteratableSpliterator.java
@@ -11,7 +11,7 @@
  * Created by johnmcclean on 22/12/2016.
  */
 
-public class IteratableSpliterator<T> extends Spliterators.AbstractSpliterator<T> implements CopyableSpliterator<T>, Printable {
+public class IteratableSpliterator<T> extends Spliterators.AbstractSpliterator<T> implements CopyableSpliterator<T>{
 
     private final Iterable<T> source;
 
@@ -40,7 +40,7 @@ public boolean tryAdvance(Consumer<? super T> action) {
         if(active==null)
             active=source.iterator();
         if (active.hasNext()) {
-            action.accept(print(active.next()));
+            action.accept(active.next());
             return true;
         }
 
diff --git a/src/main/java/com/aol/cyclops2/internal/stream/spliterators/push/ZippingOperator.java b/src/main/java/com/aol/cyclops2/internal/stream/spliterators/push/ZippingOperator.java
index 30d95c4678..001e8feb81 100644
--- a/src/main/java/com/aol/cyclops2/internal/stream/spliterators/push/ZippingOperator.java
+++ b/src/main/java/com/aol/cyclops2/internal/stream/spliterators/push/ZippingOperator.java
@@ -24,7 +24,7 @@
  * Created by johnmcclean on 12/01/2017.
  */
 @AllArgsConstructor
-public class ZippingOperator<T1,T2,R> implements Operator<R>, Printable {
+public class ZippingOperator<T1,T2,R> implements Operator<R>{
 
 
     Operator<? super T1> left;
diff --git a/src/main/java/com/aol/cyclops2/types/Folds.java b/src/main/java/com/aol/cyclops2/types/Folds.java
index 4a8adbb603..bb700bc424 100644
--- a/src/main/java/com/aol/cyclops2/types/Folds.java
+++ b/src/main/java/com/aol/cyclops2/types/Folds.java
@@ -329,7 +329,7 @@ default String join(final String sep, final String start, final String end) {
     /**
      * Write each element within this Folds in turn to the supplied PrintStream
      *
-     * @param str PrintStream to write to
+     * @param str PrintStream to tell to
      */
     default void print(final PrintStream str) {
         stream().print(str);
@@ -338,7 +338,7 @@ default void print(final PrintStream str) {
     /**
      * Write each element within this Folds in turn to the supplied PrintWriter
      *
-     * @param writer PrintWriter to write to
+     * @param writer PrintWriter to tell to
      */
     default void print(final PrintWriter writer) {
         stream().print(writer);
diff --git a/src/main/java/com/aol/cyclops2/types/futurestream/SimpleReactStream.java b/src/main/java/com/aol/cyclops2/types/futurestream/SimpleReactStream.java
index f69aaab16a..922f5f499c 100644
--- a/src/main/java/com/aol/cyclops2/types/futurestream/SimpleReactStream.java
+++ b/src/main/java/com/aol/cyclops2/types/futurestream/SimpleReactStream.java
@@ -772,7 +772,7 @@ default <T> Stream<CompletableFuture<T>> streamCompletableFutures() {
      * <pre>
      * {@code
      * List<String> result = 	SimpleReactStream.of(1,2,3)
-     * 											 .merge(FutureStream.of(100,200,300))
+     * 											 .product(FutureStream.of(100,200,300))
                                                   .map(it ->it+"!!")
                                                   .toList();
         assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
@@ -780,12 +780,12 @@ default <T> Stream<CompletableFuture<T>> streamCompletableFutures() {
      * }
      * </pre>
      *
-     * @param s Stream to merge
+     * @param s Stream to product
      *
      * @return Next stage in reactiveStream
      *
      * @see
-     * com.aol.simple.react.reactiveStream.traits.FutureStream#merge(com.aol.simple.
+     * com.aol.simple.react.reactiveStream.traits.FutureStream#product(com.aol.simple.
      * react.reactiveStream.traits.SimpleReactStream)
      */
 
diff --git a/src/main/java/cyclops/Functions.java b/src/main/java/cyclops/Functions.java
index 69a74b38aa..7717cf0e72 100644
--- a/src/main/java/cyclops/Functions.java
+++ b/src/main/java/cyclops/Functions.java
@@ -4,17 +4,17 @@
 import com.aol.cyclops2.types.Unit;
 import cyclops.collections.ListX;
 import cyclops.control.Maybe;
-import cyclops.function.Fn1;
-import cyclops.function.Monoid;
+import cyclops.function.*;
 import cyclops.monads.AnyM;
 import cyclops.monads.Witness;
 import cyclops.monads.WitnessType;
 import cyclops.stream.ReactiveSeq;
 import cyclops.typeclasses.monad.Monad;
 
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
+import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
 /**
  * Collection of useful functions
@@ -27,7 +27,7 @@
  *          {@link cyclops.function.PartialApplicator}
  *          {@link cyclops.function.Memoize}
  *          {@link cyclops.function.FluentFunctions}
- *          {@link Fn1}F
+ *          {@link Fn1}
  *          {@link Fn2}
  *          {@link Fn3}
  *          {@link Fn4}
@@ -102,4 +102,49 @@ public static final  <T> Fn1<? super Iterable<T>,? extends T> reduce(Monoid<T> m
                                 .reduce(monoid.zero(),monoid);
     }
 
+    static <K,V> Fn1<K,V> map(Map<K,V> map) {
+        return map::get;
+    }
+    static <K,V> Fn1<K,Maybe<V>> maybeMap(Map<K,V> map) {
+        return k->Maybe.ofNullable(map.get(k));
+    }
+    static <K,V> Fn1<K,Optional<V>> optionalMap(Map<K,V> map) {
+        return k-> Optional.ofNullable(map.get(k));
+    }
+
+    static <T,R,R1, R2, R3, R4> Function<T,R4> forEach4(Function<? super T, ? extends R> fn,
+                                                        Function<? super R, Function<? super T,? extends R1>> value2,
+                                                        BiFunction<? super R, ? super R1, Function<? super T,? extends R2>> value3,
+                                                        Fn3<? super R, ? super R1, ? super R2, Function<? super T,? extends R3>> value4,
+                                                        Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
+
+        Reader< T,R> rd = Reader.narrow(FluentFunctions.of(fn));
+        return rd.forEach4(value2, value3, value4, yieldingFunction);
+
+
+
+    }
+
+    static <T,R,R1, R2, R4> Function<T,R4> forEach3(Function<? super T, ? extends R> fn,
+                                                  Function<? super R, Function<? super T,? extends R1>> value2,
+                                                  BiFunction<? super R, ? super R1, Function<? super T,? extends R2>> value3,
+                                                  Fn3<? super R, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
+
+
+        Reader< T,R> rd = Reader.narrow(FluentFunctions.of(fn));
+        return rd.forEach3(value2, value3, yieldingFunction);
+    }
+
+
+
+    static <T,R,R1, R4> Function<T,R4> forEach2(Function<? super T, ? extends R> fn,
+                                                Function<? super R, Function<? super T,? extends R1>> value2,
+                                                 BiFunction<? super R, ? super R1, ? extends R4> yieldingFunction) {
+
+        Reader< T,R> rd = Reader.narrow(FluentFunctions.of(fn));
+        return rd.forEach2(value2, yieldingFunction);
+
+
+    }
+
 }
diff --git a/src/main/java/cyclops/control/ReaderWriterState.java b/src/main/java/cyclops/control/ReaderWriterState.java
index ebb532368e..de9302db64 100644
--- a/src/main/java/cyclops/control/ReaderWriterState.java
+++ b/src/main/java/cyclops/control/ReaderWriterState.java
@@ -25,7 +25,7 @@ public Tuple3<W,S,T> run(R r,S s) {
         return Fn0.run(runState.apply(r,s));
     }
 
-    public  ReaderWriterState<R,W,S,T> write(W value) {
+    public  ReaderWriterState<R,W,S,T> tell(W value) {
         BiFunction<? super R, ? super S, Free<Fn0.SupplierKind.µ,Tuple3<W,S, T>>> fn =
                 (r,s)->runState.apply(r,s).map(t3->Tuple.tuple(monoid.apply(t3.v1,value),t3.v2,t3.v3));
 
diff --git a/src/main/java/cyclops/control/Writer.java b/src/main/java/cyclops/control/Writer.java
index 10c5382b8a..4b701508ca 100644
--- a/src/main/java/cyclops/control/Writer.java
+++ b/src/main/java/cyclops/control/Writer.java
@@ -36,10 +36,14 @@ public <R> Writer<W, R> flatMap(Function<? super T,? extends  Writer<W, ? extend
         return writer(writer.value.v1, writer.monoid.apply(value.v2, writer.value.v2), writer.monoid);
     }
 
-    public Writer<W,T> write(W write){
+    public Writer<W,T> tell(W write){
         return writer(value.v1,monoid.apply(write,value.v2),monoid);
     }
 
+    public <R> Writer<W,R> set(R value){
+            return writer(value,this.value.v2,monoid);
+    }
+
     /*
      * Perform a For Comprehension over a Writer, accepting 3 generating function.
              * This results in a four level nested internal iteration over the provided Writers.
diff --git a/src/main/java/cyclops/free/Free.java b/src/main/java/cyclops/free/Free.java
index f2eb57ab46..79ea837320 100644
--- a/src/main/java/cyclops/free/Free.java
+++ b/src/main/java/cyclops/free/Free.java
@@ -10,7 +10,10 @@
 import cyclops.function.Fn5;
 import cyclops.typeclasses.functor.Functor;
 import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
 import lombok.NoArgsConstructor;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
 
 import java.util.function.BiFunction;
 import java.util.function.Function;
@@ -29,7 +32,7 @@
  * @param <T> Data type of Transformable
  */
 @NoArgsConstructor(access=AccessLevel.PRIVATE)
-public abstract class Free<F, T> implements Printable {
+public abstract class Free<F, T> {
 
     public <R1, R2, R3,R4,R5> Free<F,R5> forEach6(Function<? super T, ? extends Free<F,R1>> value2,
                                                BiFunction<? super T, ? super R1, ? extends Free<F,R2>> value3,
@@ -155,9 +158,12 @@ public final <R1> Free<F,R1> forEach2(Function<? super T, Free<F,R1>> value2) {
 
     }
     public static <F, T> Free<F, T> liftF(final Higher<F, T> value, final Functor<F> functor){
+
         return new Suspend<F, T>(functor.map(Free::done, value));
     }
 
+
+
     public static <F, T> Free<F, T> done(final T t){
         return new Pure<>(t);
     }
@@ -190,6 +196,36 @@ public abstract <R> R visit(Function<? super Pure<F,T>, ? extends R> done,
     public final <R> Xor<R, T> resume(final Functor<F> functor, Function<Higher<F,Free<F,T>>,R> decoder) {
         return resume(functor).secondaryMap(decoder);
     }
+
+
+
+    /*
+     * Functor and HKT decoder for Free
+     */
+    @AllArgsConstructor
+    static class FreeF<F,T>{
+
+        Functor<F> functor;
+        Function<Higher<F,Free<F,?>>,?> decoder1;
+
+        private <R,X> Function<Higher<F,Free<F,R>>,X> decoder(){
+            return (Function)decoder1;
+        }
+        public final <R1,R2,X1,X2> Tuple2<Xor<X1,R1>,Xor<X2,R2>> product(Free<F,R1> free1, Free<F,R2> free2 ){
+
+            return Tuple.tuple(free1.resume(functor,decoder()),free2.resume(functor,decoder()));
+
+        }
+
+    }
+
+
+    public static final <F,R1,R2,X1,X2> Tuple2<Xor<X1,R1>,Xor<X2,R2>> product(final Functor<F> functor, Free<F,R1> free1, Function<Higher<F,Free<F,R1>>,X1> decoder1,
+                                                                              Free<F,R2> free2, Function<Higher<F,Free<F,R2>>,X2> decoder2 ){
+
+        return Tuple.tuple(free1.resume(functor,decoder1),free2.resume(functor,decoder2));
+
+    }
     public final Xor<Higher<F, Free<F, T>>, T> resume(final Functor<F> functor) {
         return resumeInternal( functor).visit(Xor::secondary,Xor::primary,t->null);
 
diff --git a/src/main/java/cyclops/function/Predicates.java b/src/main/java/cyclops/function/Predicates.java
index 2cde7f4ebb..0ac6b85d19 100644
--- a/src/main/java/cyclops/function/Predicates.java
+++ b/src/main/java/cyclops/function/Predicates.java
@@ -5,10 +5,7 @@
 import cyclops.collections.ListX;
 import com.aol.cyclops2.types.Value;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 
@@ -189,6 +186,9 @@ public static <T> Predicate<T> some(final T value) {
     public static final <Y> Predicate<Y> any() {
         return __;
     };
+    public static final <Y> Predicate<Y> none() {
+        return t->false;
+    };
 
     /**
      * Match against any object that is an instance of supplied type
@@ -252,6 +252,10 @@ public static <V> Predicate<V> eq(final V value) {
 
         return test -> Objects.equals(test, value);
     }
+    public static <T1> Predicate<T1> not(final Predicate<T1> p) {
+        return p.negate();
+    }
+
 
     /**
      *  Test for equivalence
@@ -303,12 +307,28 @@ public static <V> Predicate<V> eqv2(final Value<? super V> value) {
 
     }
 
-    public static <T1> Predicate<T1> not(final Predicate<T1> p) {
-        return p.negate();
+
+    public static <T1> Predicate<T1> and(Predicate<? super T1>... preds)
+    {
+        Predicate<T1> current=  (Predicate<T1>)preds[0];
+        for(int i=1;i<preds.length;i++){
+            current = current.and((Predicate<T1>)preds[i]);
+        }
+        return current;
     }
+    public static <T1> Predicate<T1> or(Predicate<? super T1>... preds)
+    {
+        Predicate<T1> current =  (Predicate<T1>)preds[0];
+        for(int i=1;i<preds.length;i++){
+            current = current.or((Predicate<T1>)preds[i]);
+        }
+        return current;
+    }
+
 
     @SafeVarargs
     public static <T1> Predicate<T1> in(final T1... values){
+
     return test -> Arrays.asList(values)
                          .contains(test);
 }
@@ -380,23 +400,25 @@ public static <T1> Predicate<? super T1> instanceOf(final Class<?> clazz) {
 
     @SafeVarargs
     public static <T1> Predicate<? super T1> allOf(final Predicate<? super T1>... preds) {
-        return test -> ReactiveSeq.of(preds)
-                                  .map(t -> t.test(test))
-                                  .allMatch(r -> r);
+        Predicate<T1> current=  (Predicate<T1>)preds[0];
+        for(int i=1;i<preds.length;i++){
+            current = current.and((Predicate<T1>)preds[i]);
+        }
+        return current;
     }
 
     @SafeVarargs
     public static <T1> Predicate<? super T1> anyOf(final Predicate<? super T1>... preds) {
-        return test -> ReactiveSeq.of(preds)
-                                  .map(t -> t.test(test))
-                                  .anyMatch(r -> r);
+        Predicate<T1> current =  (Predicate<T1>)preds[0];
+        for(int i=1;i<preds.length;i++){
+            current = current.or((Predicate<T1>)preds[i]);
+        }
+        return current;
     }
 
     @SafeVarargs
     public static <T1> Predicate<? super T1> noneOf(final Predicate<? super T1>... preds) {
-        return test -> ReactiveSeq.of(preds)
-                                  .map(t -> t.test(test))
-                                  .noneMatch(r -> r);
+        return allOf(preds).negate();
     }
 
     @SafeVarargs
@@ -406,4 +428,9 @@ public static <T1> Predicate<? super T1> xOf(final int x, final Predicate<? supe
                                   .xMatch(x, r -> r);
     }
 
+
+    static <T1> Predicate<T1> inSet(Set<T1> set) {
+        return set::contains;
+    }
+
 }
diff --git a/src/main/java/cyclops/function/Reader.java b/src/main/java/cyclops/function/Reader.java
index b2a49e7a14..c440700b31 100644
--- a/src/main/java/cyclops/function/Reader.java
+++ b/src/main/java/cyclops/function/Reader.java
@@ -42,25 +42,26 @@ default <R1> Reader<T, R1> flatMap(final Function<? super R, ? extends Reader<T,
     }
 
 
-    default <R1, R2, R3, R4> Reader<T,R4> forEach4(Function<? super R, ? extends Function<T,R1>> value2,
-                                                                 BiFunction<? super R, ? super R1, ? extends Function<T,R2>> value3,
-                                                                 Fn3<? super R, ? super R1, ? super R2, ? extends Function<T,R3>> value4,
-                                                                 Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
+    default <R1, R2, R3, R4> Reader<T,R4> forEach4(Function<? super R, Function<? super T,? extends R1>> value2,
+                                                   BiFunction<? super R, ? super R1, Function<? super T,? extends R2>> value3,
+                                                   Fn3<? super R, ? super R1, ? super R2,Function<? super T, ? extends R3>> value4,
+                                                   Fn4<? super R, ? super R1, ? super R2, ? super R3, ? extends R4> yieldingFunction) {
 
 
-        return this.flatMap(in -> {
+        Reader<? super T, ? extends R4> res =  this.flatMap(in -> {
 
-            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
+            Reader<T,R1> a = narrow(FluentFunctions.of(value2.apply(in)));
             return a.flatMap(ina -> {
-                Reader<T,R2> b = FluentFunctions.of(value3.apply(in,ina));
+                Reader<T,R2> b = narrow(FluentFunctions.of(value3.apply(in,ina)));
                 return b.flatMap(inb -> {
 
-                    Reader<T,R3> c = FluentFunctions.of(value4.apply(in,ina,inb));
+                    Reader<T,R3> c = narrow(FluentFunctions.of(value4.apply(in,ina,inb)));
 
                     return c.map(in2 -> {
 
                          return yieldingFunction.apply(in, ina, inb, in2);
 
+
                     });
 
                 });
@@ -70,21 +71,24 @@ default <R1, R2, R3, R4> Reader<T,R4> forEach4(Function<? super R, ? extends Fun
 
 
         });
+        return (Reader<T,R4>)res;
 
     }
 
+    static <T,R>  Reader<T,R> narrow(Reader<? super T,? extends R> broad){
+        return  (Reader<T,R>)broad;
+    }
 
 
-
-    default <R1, R2, R4> Reader<T,R4> forEach3(Function<? super R, ? extends Function<T,R1>> value2,
-                                                         BiFunction<? super R, ? super R1, ? extends Function<T,R2>> value3,
+    default <R1, R2, R4> Reader<T,R4> forEach3(Function<? super R, Function<? super T,? extends R1>> value2,
+                                                         BiFunction<? super R, ? super R1, Function<? super T,? extends R2>> value3,
                                                          Fn3<? super R, ? super R1, ? super R2, ? extends R4> yieldingFunction) {
 
         return this.flatMap(in -> {
 
-            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
+            Reader<T,R1> a = narrow(FluentFunctions.of(value2.apply(in)));
             return a.flatMap(ina -> {
-                Reader<T,R2> b = FluentFunctions.of(value3.apply(in,ina));
+                Reader<T,R2> b = narrow(FluentFunctions.of(value3.apply(in,ina)));
                 return b.map(in2 -> {
                         return yieldingFunction.apply(in, ina, in2);
 
@@ -100,12 +104,12 @@ default <R1, R2, R4> Reader<T,R4> forEach3(Function<? super R, ? extends Functio
 
 
 
-    default <R1, R4> Reader<T,R4> forEach2(Function<? super R, Function<T,R1>> value2,
+    default <R1, R4> Reader<T,R4> forEach2(Function<? super R, Function<? super T,? extends R1>> value2,
                                                 BiFunction<? super R, ? super R1, ? extends R4> yieldingFunction) {
 
         return this.flatMap(in -> {
 
-            Reader<T,R1> a = FluentFunctions.of(value2.apply(in));
+            Reader<T,R1> a = narrow(FluentFunctions.of(value2.apply(in)));
             return a.map(in2 -> {
                     return yieldingFunction.apply(in, in2);
 
diff --git a/src/main/java/cyclops/stream/ReactiveSeq.java b/src/main/java/cyclops/stream/ReactiveSeq.java
index 81377a70b2..34305bfb7a 100644
--- a/src/main/java/cyclops/stream/ReactiveSeq.java
+++ b/src/main/java/cyclops/stream/ReactiveSeq.java
@@ -798,7 +798,7 @@ default <R> R foldParallel(Function<? super Stream<T>,? extends R> fn){
 
                     if(ref.get()==null && ref.compareAndSet(null,Continuation.empty())){
                         try {
-                            //use the first consuming thread to write this Stream onto the Queue
+                            //use the first consuming thread to tell this Stream onto the Queue
                             this.spliterator().forEachRemaining(queue::offer);
                         }finally {
                             queue.close();
@@ -4838,7 +4838,7 @@ default Topic<T> broadcast(){
                     if(wip.compareAndSet(false,true)){
                         try {
 
-                            //use the first consuming thread to write this Stream onto the Queue
+                            //use the first consuming thread to tell this Stream onto the Queue
                             if(!split.tryAdvance(topic::offer)){
                                 topic.close();
                                 return Continuation.empty();
diff --git a/src/test/java/com/aol/cyclops2/streams/BaseSequentialTest.java b/src/test/java/com/aol/cyclops2/streams/BaseSequentialTest.java
index e6a8273891..d409d0c27a 100644
--- a/src/test/java/com/aol/cyclops2/streams/BaseSequentialTest.java
+++ b/src/test/java/com/aol/cyclops2/streams/BaseSequentialTest.java
@@ -242,7 +242,7 @@ public void changes() {
     @Test
     public void publishToAndMerge() {
         for (int k = 0; k < ITERATIONS; k++) {
-            System.out.println("Publish to and merge iteration " + k);
+            System.out.println("Publish to and product iteration " + k);
             cyclops.async.Queue<Integer> queue = QueueFactories.<Integer>boundedNonBlockingQueue(10)
                     .build();
 
@@ -406,10 +406,10 @@ public void mergePTest() {
     public void triplicateFanOut() {
 
         for (int k = 0; k < ITERATIONS; k++) {
-            System.out.println("******************Triplicate & merge.. " + k);
-            System.out.println("******************Triplicate & merge.. " + k);
-            System.out.println("******************Triplicate & merge.. " + k);
-            System.out.println("******************Triplicate & merge.. " + k);
+            System.out.println("******************Triplicate & product.. " + k);
+            System.out.println("******************Triplicate & product.. " + k);
+            System.out.println("******************Triplicate & product.. " + k);
+            System.out.println("******************Triplicate & product.. " + k);
             ListX<Integer> res = of(1, 2, 3, 4, 5, 6, 7, 8, 9)
                     .fanOut(s1 -> s1.peek(System.out::println).filter(i -> i % 3 == 0).map(i -> i * 2),
                             s2 -> s2.filter(i -> i % 3 == 1).map(i -> i * 100),
diff --git a/src/test/java/cyclops/free/CharToy.java b/src/test/java/cyclops/free/CharToy.java
index f0b8736e16..650b14b78b 100644
--- a/src/test/java/cyclops/free/CharToy.java
+++ b/src/test/java/cyclops/free/CharToy.java
@@ -60,7 +60,7 @@ public Either3<CharOutput<A>, CharBell<A>, CharDone<A>> match() {
         }
 
 
-        public <Z> Z fold(final Fn2<Character, A, Z> output) {
+        public <Z> Z visit(final Fn2<Character, A, Z> output) {
             return output.apply(a, next);
         }
 
@@ -82,7 +82,7 @@ public Either3<CharOutput<A>, CharBell<A>, CharDone<A>> match() {
         }
 
 
-        public <Z> Z fold(final Fn1<A, Z> bell) {
+        public <Z> Z visit(final Fn1<A, Z> bell) {
             return bell.apply(next);
         }
 
@@ -99,7 +99,7 @@ public Either3<CharOutput<A>, CharBell<A>, CharDone<A>> match() {
         }
 
 
-        public <Z> Z fold(final Z done) {
+        public <Z> Z visit(final Z done) {
             return done;
         }
 
diff --git a/src/test/java/cyclops/free/FreeTest.java b/src/test/java/cyclops/free/FreeTest.java
index 8b19d5cd2d..8ece3ca3a2 100644
--- a/src/test/java/cyclops/free/FreeTest.java
+++ b/src/test/java/cyclops/free/FreeTest.java
@@ -1,9 +1,14 @@
 package cyclops.free;
 
 
+import static cyclops.free.CharToy.bell;
+import static cyclops.free.CharToy.done;
+import static cyclops.free.CharToy.output;
 import static cyclops.function.Fn0.SupplierKind;
 
+import cyclops.control.Xor;
 import cyclops.function.Fn0;
+import org.jooq.lambda.tuple.Tuple2;
 import org.junit.Test;
 
 import cyclops.free.CharToy.*;
@@ -52,16 +57,68 @@ public void interpreter(){
 
 
         assertThat(expected,equalTo(
-                showProgram(CharToy.output('A')
-                                   .forEach4(unit1 -> CharToy.bell(),
-                                             (unit1,unit2) -> CharToy.output('B'),
-                                             (u1,u2,u3)->CharToy.done()))));
+                showProgram(output('A')
+                                   .forEach4(unit1 -> bell(),
+                                             (unit1,unit2) -> output('B'),
+                                             (u1,u2,u3)-> done()))));
     }
+    @Test
+    public void interpreterInterleave(){
+        String expected = "emitted A\n" +
+                "bell \n" +
+                "emitted B\n" +
+                "done\n";
+
+
+
+        Free<µ, Void> one =                   output('A')
+                .forEach4(__ ->               bell(),
+                         (__, ___) ->         output('B'),
+                         (__, ___, ____) ->   done());
+
+        Free<µ, Void> two =                   output('C')
+                .forEach4(__ ->               bell(),
+                         (__, ___) ->         output('D'),
+                         (__, ___, ____) ->   done());
+
+
+        assertThat(expected,equalTo(
+                                interleaveProgram(one,two)));
+    }
+
+    static <R> String interleaveProgram(Free<CharToy.µ,R> program1,Free<CharToy.µ,R> program2){
+
+        Tuple2<Xor<CharToy<Free<µ, R>>, R>, Xor<CharToy<Free<µ, R>>, R>> tuple = Free.product(CharToy.functor, program1, CharToy::narrowK, program2, CharToy::narrowK);
+        Xor<CharToy<Free<µ, R>>, R> a = tuple.v1;
+        Xor<CharToy<Free<µ, R>>, R> b = tuple.v2;
 
 
+
+
+        String one =a.visit(
+                        r ->   r.match()
+                                .visit(o->interleaveOutput(o,program2),
+                                        FreeTest::handleBell,
+                                        FreeTest::handleDone)
+                        ,
+                        FreeTest::handleReturn
+                    );
+        String two = b.visit(
+                r ->   r.match()
+                        .visit(o->interleaveOutput1(o,program1),
+                                FreeTest::handleBell,
+                                FreeTest::handleDone)
+                ,
+                FreeTest::handleReturn
+        );
+        return one +two;
+
+    }
+
     static <R> String showProgram(Free<CharToy.µ,R> program){
+        Xor<CharToy<Free<µ, R>>, R> xor = program.resume(CharToy.functor, CharToy::narrowK);
 
-       return program.resume(CharToy.functor, CharToy::narrowK)
+        return program.resume(CharToy.functor, CharToy::narrowK)
                 .visit(
                         r ->   r.match()
                                 .visit(FreeTest::handleOutput,
@@ -76,14 +133,26 @@ static <R> String handleReturn(R r){
         return "return " + r + "\n";
     }
     static <R> String handleOutput(CharOutput<Free<CharToy.µ,R>> output){
-        return output.fold((a, next) -> "emitted " + a + "\n" + showProgram(next));
+        return output.visit((a, next) -> "emitted " + a + "\n" + showProgram(next));
     }
 
     static <R> String handleBell(CharBell<Free<CharToy.µ, R>> bell){
-       return bell.fold(next -> "bell " + "\n" + showProgram(next));
+       return bell.visit(next -> "bell " + "\n" + showProgram(next));
     }
 
     static <T> String handleDone(CharDone<T> done){
         return "done\n";
     }
+
+    static <R> String interleaveOutput(CharOutput<Free<CharToy.µ,R>> output,Free<CharToy.µ,R> program2){
+        System.out.println("Running interA");
+        return output.visit((a, next) -> "emitted " + a + "\n" + interleaveProgram(next,program2));
+    }
+
+    static <R> String interleaveOutput1(CharOutput<Free<CharToy.µ,R>> output,Free<CharToy.µ,R> program1){
+        System.out.println("Running interB");
+        return output.visit((a, next) -> "emitted " + a + "\n" + interleaveProgram(program1,next));
+    }
+
+
 }
\ No newline at end of file
diff --git a/src/test/java/cyclops/monads/KleisliTest.java b/src/test/java/cyclops/monads/KleisliTest.java
index 49a4045b60..af2d2e694e 100644
--- a/src/test/java/cyclops/monads/KleisliTest.java
+++ b/src/test/java/cyclops/monads/KleisliTest.java
@@ -1,13 +1,16 @@
 package cyclops.monads;
 
+import cyclops.collections.ListX;
 import cyclops.monads.Witness.stream;
 import cyclops.monads.Witness.reactiveSeq;
 import cyclops.stream.ReactiveSeq;
 import org.junit.Test;
 
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static cyclops.monads.Kleisli.kleisli;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.*;
 
 /**
@@ -15,23 +18,29 @@
  */
 public class KleisliTest {
 
+    @Test
+    public void local(){
+        Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(t);
+        assertThat(ListX.of(3),equalTo(k1.local(i->i+1).apply(2).to(Witness::stream).collect(Collectors.toList())));
+    }
+
     @Test
     public void flatMap(){
         Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(1);
 
-        k1.flatMap(i-> t->AnyM.fromArray(i+t))
+        assertThat(ListX.of(11),equalTo(k1.flatMap(i-> t->AnyM.fromArray(i+t))
                 .apply(10)
-                .forEach(System.out::println);
+                .collect(Collectors.toList())));
     }
     @Test
     public void example(){
         Kleisli<reactiveSeq, Integer, Integer> k1 = t -> ReactiveSeq.iterate(0,i->i<t, i->i+1)
                                                                             .anyM();
 
-        k1.flatMap(i-> t-> ReactiveSeq.of(t+i)
+        assertThat(ListX.iterate(10,10,i->i+1),equalTo(k1.flatMap(i-> t-> ReactiveSeq.of(t+i)
                                       .anyM())
                 .apply(10)
-                .forEach(System.out::println);
+                .collect(Collectors.toList())));
     }
     @Test
     public void flatMapA(){

From 6ed13e7434e90396e612900b5da167baa9da6f81 Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Fri, 10 Feb 2017 11:23:49 +0000
Subject: [PATCH 12/14] add for comps

---
 .../cyclops/control/ReaderWriterState.java    |   4 +-
 src/main/java/cyclops/free/FreePrograms.java  | 230 ++++++++++++++++++
 2 files changed, 232 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/cyclops/free/FreePrograms.java

diff --git a/src/main/java/cyclops/control/ReaderWriterState.java b/src/main/java/cyclops/control/ReaderWriterState.java
index de9302db64..b56e0561a6 100644
--- a/src/main/java/cyclops/control/ReaderWriterState.java
+++ b/src/main/java/cyclops/control/ReaderWriterState.java
@@ -18,8 +18,8 @@ public class ReaderWriterState<R,W,S,T>  {
     public static class µ {
     }
 
-    Monoid<W> monoid;
-    BiFunction<R,S, Free<Fn0.SupplierKind.µ,Tuple3<W, S, T>>> runState;
+    private final Monoid<W> monoid;
+    private final BiFunction<R,S, Free<Fn0.SupplierKind.µ,Tuple3<W, S, T>>> runState;
 
     public Tuple3<W,S,T> run(R r,S s) {
         return Fn0.run(runState.apply(r,s));
diff --git a/src/main/java/cyclops/free/FreePrograms.java b/src/main/java/cyclops/free/FreePrograms.java
new file mode 100644
index 0000000000..f8821a4edb
--- /dev/null
+++ b/src/main/java/cyclops/free/FreePrograms.java
@@ -0,0 +1,230 @@
+package cyclops.free;
+
+import cyclops.function.Fn3;
+import cyclops.function.Fn4;
+import cyclops.function.Fn5;
+import org.jooq.lambda.tuple.*;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/**
+ * Static for comprehensions for working with Free
+ */
+public interface FreePrograms {
+    public static <T,F,R1, R2, R3,R4,R5,R6,R7> Free<F,R7> forEach(Free<F,T> free,
+                                                              Function<? super T, ? extends Free<F,R1>> value2,
+                                                              Function<? super Tuple2<? super T,? super R1>, ? extends Free<F,R2>> value3,
+                                                              Function<? super Tuple3<? super T,? super R1,? super R2>, ? extends Free<F,R3>> value4,
+                                                              Function<? super Tuple4<? super T, ? super R1, ? super R2,? super R3>, ? extends Free<F,R4>> value5,
+                                                              Function<? super Tuple5<T, ? super R1, ? super R2,? super R3, ? super R4>, ? extends Free<F,R5>> value6,
+                                                              Function<? super Tuple6<T, ? super R1, ? super R2,? super R3, ? super R4, ? super R5>, ? extends Free<F,R6>> value7,
+                                                              Function<? super Tuple7<T, ? super R1, ? super R2,? super R3, ? super R4, ? super R5, ? super R6>, ? extends Free<F,R7>> value8
+    ) {
+
+        return free.flatMap(in -> {
+
+            Free<F,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Free<F,R2> b = value3.apply(Tuple.tuple(in,ina));
+                return b.flatMap(inb -> {
+
+                    Free<F,R3> c = value4.apply(Tuple.tuple(in,ina,inb));
+
+                    return c.flatMap(inc->{
+                        Free<F,R4> d = value5.apply(Tuple.tuple(in,ina,inb,inc));
+                        return d.flatMap(ind->{
+                            Free<F,R5> e = value6.apply(Tuple.tuple(in,ina,inb,inc,ind));
+                            return e.flatMap(ine->{
+                                Free<F,R6> f = value7.apply(Tuple.tuple(in,ina,inb,inc,ind,ine));
+                                return f.flatMap(inf->{
+                                    Free<F,R7> g = value8.apply(Tuple.tuple(in,ina,inb,inc,ind,ine,inf));
+                                    return g;
+
+                                });
+
+                            });
+                        });
+
+                    });
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+    public static <T,F,R1, R2, R3,R4,R5,R6> Free<F,R6> forEach(Free<F,T> free,
+                                                           Function<? super T, ? extends Free<F,R1>> value2,
+                                                           Function<? super Tuple2<? super T,? super R1>, ? extends Free<F,R2>> value3,
+                                                           Function<? super Tuple3<? super T,? super R1,? super R2>, ? extends Free<F,R3>> value4,
+                                                           Function<? super Tuple4<? super T, ? super R1, ? super R2,? super R3>, ? extends Free<F,R4>> value5,
+                                                           Function<? super Tuple5<T, ? super R1, ? super R2,? super R3, ? super R4>, ? extends Free<F,R5>> value6,
+                                                              Function<? super Tuple6<T, ? super R1, ? super R2,? super R3, ? super R4, ? super R5>, ? extends Free<F,R6>> value7
+    ) {
+
+        return free.flatMap(in -> {
+
+            Free<F,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Free<F,R2> b = value3.apply(Tuple.tuple(in,ina));
+                return b.flatMap(inb -> {
+
+                    Free<F,R3> c = value4.apply(Tuple.tuple(in,ina,inb));
+
+                    return c.flatMap(inc->{
+                        Free<F,R4> d = value5.apply(Tuple.tuple(in,ina,inb,inc));
+                        return d.flatMap(ind->{
+                            Free<F,R5> e = value6.apply(Tuple.tuple(in,ina,inb,inc,ind));
+                            return e.flatMap(ine->{
+                                Free<F,R6> f = value7.apply(Tuple.tuple(in,ina,inb,inc,ind,ine));
+                                return f;
+                            });
+                        });
+
+                    });
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+
+    public static <T,F,R1, R2, R3,R4,R5> Free<F,R5> forEach(Free<F,T> free,
+                                                        Function<? super T, ? extends Free<F,R1>> value2,
+                                                        Function<? super Tuple2<? super T,? super R1>, ? extends Free<F,R2>> value3,
+                                                        Function<? super Tuple3<? super T,? super R1,? super R2>, ? extends Free<F,R3>> value4,
+                                                        Function<? super Tuple4<? super T, ? super R1, ? super R2,? super R3>, ? extends Free<F,R4>> value5,
+                                                        Function<? super Tuple5<T, ? super R1, ? super R2,? super R3, ? super R4>, ? extends Free<F,R5>> value6
+    ) {
+
+        return free.flatMap(in -> {
+
+            Free<F,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Free<F,R2> b = value3.apply(Tuple.tuple(in,ina));
+                return b.flatMap(inb -> {
+
+                    Free<F,R3> c = value4.apply(Tuple.tuple(in,ina,inb));
+
+                    return c.flatMap(inc->{
+                        Free<F,R4> d = value5.apply(Tuple.tuple(in,ina,inb,inc));
+                        return d.flatMap(ind->{
+                            Free<F,R5> e = value6.apply(Tuple.tuple(in,ina,inb,inc,ind));
+                            return e;
+                        });
+                    });
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+    public static <T,F,R1, R2, R3,R4> Free<F,R4> forEach(Free<F,T> free,
+                                                            Function<? super T, ? extends Free<F,R1>> value2,
+                                                            Function<? super Tuple2<? super T,? super R1>, ? extends Free<F,R2>> value3,
+                                                            Function<? super Tuple3<? super T,? super R1,? super R2>, ? extends Free<F,R3>> value4,
+                                                            Function<? super Tuple4<? super T, ? super R1, ? super R2,? super R3>, ? extends Free<F,R4>> value5
+
+    ) {
+
+        return free.flatMap(in -> {
+
+            Free<F,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Free<F,R2> b = value3.apply(Tuple.tuple(in,ina));
+                return b.flatMap(inb -> {
+
+                    Free<F,R3> c = value4.apply(Tuple.tuple(in,ina,inb));
+
+                    return c.flatMap(inc->{
+                        Free<F,R4> d = value5.apply(Tuple.tuple(in,ina,inb,inc));
+                        return d;
+                    });
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+    public static <T,F,R1, R2, R3> Free<F,R3> forEach(Free<F,T> free,
+                                                         Function<? super T, ? extends Free<F,R1>> value2,
+                                                         Function<? super Tuple2<? super T,? super R1>, ? extends Free<F,R2>> value3,
+                                                         Function<? super Tuple3<? super T,? super R1,? super R2>, ? extends Free<F,R3>> value4
+
+    ) {
+
+        return free.flatMap(in -> {
+
+            Free<F,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Free<F,R2> b = value3.apply(Tuple.tuple(in,ina));
+                return b.flatMap(inb -> {
+
+                    Free<F,R3> c = value4.apply(Tuple.tuple(in,ina,inb));
+
+                    return c;
+
+                });
+
+
+            });
+
+
+        });
+
+    }
+    public static <T,F,R1, R2> Free<F,R2> forEach(Free<F,T> free,
+                                                      Function<? super T, ? extends Free<F,R1>> value2,
+                                                      Function<? super Tuple2<? super T,? super R1>, ? extends Free<F,R2>> value3
+
+    ) {
+
+        return free.flatMap(in -> {
+
+            Free<F,R1> a = value2.apply(in);
+            return a.flatMap(ina -> {
+                Free<F,R2> b = value3.apply(Tuple.tuple(in,ina));
+                return b;
+
+
+            });
+
+
+        });
+
+    }
+    public static <T,F,R1> Free<F,R1> forEach(Free<F,T> free,
+                                                  Function<? super T, ? extends Free<F,R1>> value2
+
+
+    ) {
+
+        return free.flatMap(in -> {
+
+            Free<F,R1> a = value2.apply(in);
+            return a;
+
+
+        });
+
+    }
+
+
+
+}

From 0424d22becbdd1b1316f253ebda9585c64f355bd Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 15 Feb 2017 11:48:52 +0000
Subject: [PATCH 13/14] more tests, lazy persistent col constructors

---
 There                                         |  0
 .../extensions/lazy/LazyListX.java            | 29 +---------------
 .../extensions/lazy/immutable/LazyPBagX.java  |  7 +++-
 .../lazy/immutable/LazyPOrderedSetX.java      |  7 +++-
 .../lazy/immutable/LazyPQueueX.java           |  7 +++-
 .../extensions/lazy/immutable/LazyPSetX.java  |  7 +++-
 .../lazy/immutable/LazyPStackX.java           |  7 +++-
 .../lazy/immutable/LazyPVectorX.java          |  5 ++-
 src/main/java/cyclops/free/FreePrograms.java  |  2 ++
 src/test/java/cyclops/monads/KleisliTest.java | 34 +++++++++++++++++++
 10 files changed, 71 insertions(+), 34 deletions(-)
 delete mode 100644 There

diff --git a/There b/There
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/LazyListX.java b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/LazyListX.java
index 0db8d912a5..0a092f737e 100644
--- a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/LazyListX.java
+++ b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/LazyListX.java
@@ -147,34 +147,7 @@ public <U> LazyListX<U> unitIterator(Iterator<U> it) {
     }
 
 
-    public static void main(String[] args){
-
-        ReactiveSeq<Integer> stream = ReactiveSeq.of(1,2,3);
-        stream.map(i->i*2).printOut();
-        ReactiveSeq<Integer> r2 = stream.map(i->i*2);
-        r2.map(i->i*100).zipWithIndex().printOut();
-        r2.map(i->i*1000).zipWithIndex().printOut();
-       /**
-        LazyListX<Integer> l2 = new LazyListX<>(null,ReactiveSeq.of(1,2,3), Collectors.toList());
-        l2.map(i->i*100).printOut();
-        l2.map(i->i*1000).printOut();
-**/
-        /**
-       // LazyListX<Integer> list = new LazyListX<>(null,ReactiveSeq.of(1,2,3), Collectors.toList());
-        LazyListX<Integer> list = new LazyListX<>(Arrays.asList(1,2,3),null, Collectors.toList());
-
-        list.map(i->i*2).printOut();
-        ListX<Integer> l2 = list.map(i->i*2);
-        System.out.println(l2.getClass());
-        list.map(i->i*3)
-            .peek(System.out::println)
-        .forEach(System.err::println);
-
-        l2.map(i->i*100).printOut();
-        System.out.println(l2.getClass() + " " + ((LazyListX)l2).getList());
-        l2.map(i->i*1000).printOut();
-**/
-    }
+
 
     @Override
     public <R> LazyListX<R> unit(Collection<R> col) {
diff --git a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPBagX.java b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPBagX.java
index 6bb171b2d8..4b0498ad10 100644
--- a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPBagX.java
+++ b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPBagX.java
@@ -1,9 +1,9 @@
 package com.aol.cyclops2.data.collections.extensions.lazy.immutable;
 
 
-import com.aol.cyclops2.data.collections.extensions.persistent.PersistentCollectionX;
 import cyclops.Reducers;
 import cyclops.collections.immutable.PBagX;
+import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
 import org.pcollections.PBag;
 
@@ -47,6 +47,11 @@ public LazyPBagX(PBag<T> list, ReactiveSeq<T> seq) {
         super(list, seq, Reducers.toPBag());
         
 
+    }
+    public LazyPBagX(PBag<T> list, ReactiveSeq<T> seq, Reducer<PBag<T>> reducer) {
+        super(list, seq, reducer);
+
+
     }
     public LazyPBagX(PBag<T> list) {
         super(list, null, Reducers.toPBag());
diff --git a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPOrderedSetX.java b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPOrderedSetX.java
index c064db64d8..92f4689bee 100644
--- a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPOrderedSetX.java
+++ b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPOrderedSetX.java
@@ -2,8 +2,8 @@
 
 
 import cyclops.Reducers;
-import cyclops.collections.immutable.PBagX;
 import cyclops.collections.immutable.POrderedSetX;
+import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
 import org.pcollections.POrderedSet;
 
@@ -47,6 +47,11 @@ public LazyPOrderedSetX(POrderedSet<T> list, ReactiveSeq<T> seq) {
         super(list, seq, Reducers.toPOrderedSet());
         
 
+    }
+    public LazyPOrderedSetX(POrderedSet<T> list, ReactiveSeq<T> seq, Reducer<POrderedSet<T>> reducer) {
+        super(list, seq, reducer);
+
+
     }
     public LazyPOrderedSetX(POrderedSet<T> list) {
         super(list, null, Reducers.toPOrderedSet());
diff --git a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPQueueX.java b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPQueueX.java
index 6fd2756d5b..c984d43c5f 100644
--- a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPQueueX.java
+++ b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPQueueX.java
@@ -2,8 +2,8 @@
 
 
 import cyclops.Reducers;
-import cyclops.collections.immutable.PBagX;
 import cyclops.collections.immutable.PQueueX;
+import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
 import org.pcollections.PQueue;
 
@@ -47,6 +47,11 @@ public LazyPQueueX(PQueue<T> list, ReactiveSeq<T> seq) {
         super(list, seq, Reducers.toPQueue());
         
 
+    }
+    public LazyPQueueX(PQueue<T> list, ReactiveSeq<T> seq, Reducer<PQueue<T>> reducer) {
+        super(list, seq, reducer);
+
+
     }
     public LazyPQueueX(PQueue<T> list) {
         super(list, null, Reducers.toPQueue());
diff --git a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPSetX.java b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPSetX.java
index 9060235cca..1241be9d6c 100644
--- a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPSetX.java
+++ b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPSetX.java
@@ -2,8 +2,8 @@
 
 
 import cyclops.Reducers;
-import cyclops.collections.immutable.PBagX;
 import cyclops.collections.immutable.PSetX;
+import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
 import org.pcollections.PSet;
 
@@ -47,6 +47,11 @@ public LazyPSetX(PSet<T> list, ReactiveSeq<T> seq) {
         super(list, seq, Reducers.toPSet());
         
 
+    }
+    public LazyPSetX(PSet<T> list, ReactiveSeq<T> seq, Reducer<PSet<T>> reducer) {
+        super(list, seq, reducer);
+
+
     }
     public LazyPSetX(PSet<T> list) {
         super(list, null, Reducers.toPSet());
diff --git a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPStackX.java b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPStackX.java
index 8f96a6c97b..b26f1f7dd0 100644
--- a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPStackX.java
+++ b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPStackX.java
@@ -2,8 +2,8 @@
 
 
 import cyclops.Reducers;
-import cyclops.collections.immutable.PBagX;
 import cyclops.collections.immutable.PStackX;
+import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
 import lombok.Getter;
 import org.pcollections.PStack;
@@ -51,6 +51,11 @@ public LazyPStackX(PStack<T> list, ReactiveSeq<T> seq, boolean efficientOps) {
         super(list, seq, Reducers.toPStack());
         this.efficientOps= efficientOps;
 
+    }
+    public LazyPStackX(PStack<T> list, ReactiveSeq<T> seq, boolean efficientOps, Reducer<PStack<T>> reducer) {
+        super(list, seq, reducer);
+        this.efficientOps= efficientOps;
+
     }
     public LazyPStackX(PStack<T> list,boolean efficientOps) {
         super(list, null, Reducers.toPStack());
diff --git a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPVectorX.java b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPVectorX.java
index c678ba980e..7d105d8865 100644
--- a/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPVectorX.java
+++ b/src/main/java/com/aol/cyclops2/data/collections/extensions/lazy/immutable/LazyPVectorX.java
@@ -2,8 +2,8 @@
 
 
 import cyclops.Reducers;
-import cyclops.collections.immutable.PBagX;
 import cyclops.collections.immutable.PVectorX;
+import cyclops.function.Reducer;
 import cyclops.stream.ReactiveSeq;
 import org.pcollections.PVector;
 
@@ -45,6 +45,9 @@ public LazyPVectorX(PVector<T> list, ReactiveSeq<T> seq) {
         super(list, seq, Reducers.toPVector());
 
 
+    }
+    public LazyPVectorX(PVector<T> list, ReactiveSeq<T> seq, Reducer<PVector<T>> reducer) {
+        super(list, seq, reducer);
     }
     public LazyPVectorX(PVector<T> list) {
         super(list, null, Reducers.toPVector());
diff --git a/src/main/java/cyclops/free/FreePrograms.java b/src/main/java/cyclops/free/FreePrograms.java
index f8821a4edb..09e9cfb050 100644
--- a/src/main/java/cyclops/free/FreePrograms.java
+++ b/src/main/java/cyclops/free/FreePrograms.java
@@ -12,6 +12,8 @@
  * Static for comprehensions for working with Free
  */
 public interface FreePrograms {
+
+
     public static <T,F,R1, R2, R3,R4,R5,R6,R7> Free<F,R7> forEach(Free<F,T> free,
                                                               Function<? super T, ? extends Free<F,R1>> value2,
                                                               Function<? super Tuple2<? super T,? super R1>, ? extends Free<F,R2>> value3,
diff --git a/src/test/java/cyclops/monads/KleisliTest.java b/src/test/java/cyclops/monads/KleisliTest.java
index af2d2e694e..a423c08538 100644
--- a/src/test/java/cyclops/monads/KleisliTest.java
+++ b/src/test/java/cyclops/monads/KleisliTest.java
@@ -1,9 +1,12 @@
 package cyclops.monads;
 
 import cyclops.collections.ListX;
+import cyclops.control.Xor;
 import cyclops.monads.Witness.stream;
 import cyclops.monads.Witness.reactiveSeq;
 import cyclops.stream.ReactiveSeq;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple2;
 import org.junit.Test;
 
 import java.util.stream.Collectors;
@@ -17,6 +20,37 @@
  * Created by johnmcclean on 06/02/2017.
  */
 public class KleisliTest {
+    @Test
+    public void firstK(){
+        Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(t);
+        assertThat(ListX.of(10),
+                equalTo(k1.firstK().apply(Tuple.tuple(10,-1)).reactiveSeq().map(Tuple2::v1).toList()));
+    }
+
+    @Test
+    public void secondK(){
+        Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(t);
+        assertThat(ListX.of(-1),
+                equalTo(k1.secondK().apply(Tuple.tuple(10,-1)).reactiveSeq().map(Tuple2::v2).toList()));
+    }
+    @Test
+    public void leftK(){
+        Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(t);
+        assertThat(ListX.of(10),
+                equalTo(k1.leftK(stream.INSTANCE).apply(Xor.secondary(10)).reactiveSeq().map(Xor::secondaryGet).toList()));
+    }
+    @Test
+    public void rightK(){
+        Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(t);
+        assertThat(ListX.of(10),
+                equalTo(k1.rightK(stream.INSTANCE).apply(Xor.primary(10)).reactiveSeq().map(Xor::get).toList()));
+    }
+    @Test
+    public void andThen(){
+        Kleisli<stream, Integer, Integer> k1 = t -> AnyM.fromArray(t);
+        assertThat("10",equalTo(k1.andThen(s->s.reactiveSeq()
+                                                        .join()).apply(10)));
+    }
 
     @Test
     public void local(){

From 85bfb33eb2f17d2f1b04e749255695244f5db9ac Mon Sep 17 00:00:00 2001
From: John McClean <john.mcclean@teamaol.com>
Date: Wed, 15 Feb 2017 14:44:13 +0000
Subject: [PATCH 14/14] bump versions

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 73ee4bb796..846ee85d2b 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,4 @@
-version = 2.0.0-MI3
+version = 2.0.0-MI4
 lombokVersion=1.16.12
 joolVersion=0.9.12
 pCollectionsVersion=2.1.2