diff --git a/Sources/FunctionalKit/Adapter.swift b/Sources/FunctionalKit/Adapter.swift
index 5861d5d..6810ab8 100644
--- a/Sources/FunctionalKit/Adapter.swift
+++ b/Sources/FunctionalKit/Adapter.swift
@@ -36,8 +36,8 @@ public extension Writer {
 
 public extension Result {
 	enum iso {
-		public static var coproduct: Iso<Result,Coproduct<Failure,Parameter>> {
-			return Iso<Result,Coproduct<Failure,Parameter>>.init(
+		public static var coproduct: Iso<Result,Coproduct<Failure,Success>> {
+			return Iso<Result,Coproduct<Failure,Success>>.init(
 				from: {
 					switch $0 {
 					case let .success(value):
diff --git a/Sources/FunctionalKit/Array.swift b/Sources/FunctionalKit/Array.swift
index 8d9b1dd..59225ce 100644
--- a/Sources/FunctionalKit/Array.swift
+++ b/Sources/FunctionalKit/Array.swift
@@ -104,7 +104,7 @@ public extension Array {
         }
     }
 
-	func traverse <A,F> (_ transform: (ParameterType) -> Result<F,A>) -> Result<F,Array<A>> {
+	func traverse <A,F> (_ transform: (ParameterType) -> Result<A,F>) -> Result<Array<A>,F> {
 		return reduce(Result.pure([])) { previous, element in
 			Result.pure(f.curry(++)) <*> previous <*> transform(element)
 		}
diff --git a/Sources/FunctionalKit/FunctorTransformers2.generated.swift b/Sources/FunctionalKit/FunctorTransformers2.generated.swift
index 7e6085c..3469229 100644
--- a/Sources/FunctionalKit/FunctorTransformers2.generated.swift
+++ b/Sources/FunctionalKit/FunctorTransformers2.generated.swift
@@ -3,448 +3,211 @@
 
 
 
-
-
-
-
-
-
 public extension Array {
-
-
-
-
 	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Array<Array<Output>> where ParameterType == Array<Input> {
         return fmap { $0.fmap(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Output>> where ParameterType == Effect<Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Output>> where ParameterType == Future<Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Array<Optional<Output>> where ParameterType == Optional<Input> {
         return fmap { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
         return fmap { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Array<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
         return fmap { $0.map(transform) }
     }
 }
-
-
-
-
 public extension Effect {
-
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Output>> where ParameterType == Array<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Output>> where ParameterType == Effect<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Output>> where ParameterType == Future<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Output>> where ParameterType == Optional<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
         return map { $0.map(transform) }
     }
 }
-
-
-
-
 public extension Future {
-
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Output>> where ParameterType == Array<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Output>> where ParameterType == Effect<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Output>> where ParameterType == Future<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Output>> where ParameterType == Optional<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
         return map { $0.map(transform) }
     }
 }
-
-
-
-
 public extension Optional {
-
-
-
-
 	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Optional<Array<Output>> where ParameterType == Array<Input> {
         return fmap { $0.fmap(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Output>> where ParameterType == Effect<Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Output>> where ParameterType == Future<Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Optional<Optional<Output>> where ParameterType == Optional<Input> {
         return fmap { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
         return fmap { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
         return fmap { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Optional<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
         return fmap { $0.map(transform) }
     }
 }
-
-
-
-
 public extension Reader {
-
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Output>> where ParameterType == Array<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Output>> where ParameterType == Effect<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Output>> where ParameterType == Future<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Output>> where ParameterType == Optional<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
         return map { $0.map(transform) }
     }
 }
-
-
-
-
 public extension Result {
-
-
-
-
-	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Array<Output>> where ParameterType == Array<Input> {
+	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Result<Array<Output>,Failure> where ParameterType == Array<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Output>> where ParameterType == Effect<Input> {
+	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Output>,Failure> where ParameterType == Effect<Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Output>> where ParameterType == Future<Input> {
+	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Output>,Failure> where ParameterType == Future<Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Optional<Output>> where ParameterType == Optional<Input> {
+	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Result<Optional<Output>,Failure> where ParameterType == Optional<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary,Output>,Failure> where ParameterType == Reader<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Result<Result<Output,Secondary>,Failure> where ParameterType == Result<Input,Secondary> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary,Output>,Failure> where ParameterType == State<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Result<Writer<Secondary,Output>,Failure> where ParameterType == Writer<Secondary,Input> {
         return map { $0.map(transform) }
     }
 }
-
-
-
-
 public extension State {
-
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Output>> where ParameterType == Array<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Output>> where ParameterType == Effect<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Output>> where ParameterType == Future<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Output>> where ParameterType == Optional<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
         return map { $0.map(transform) }
     }
 }
-
-
-
-
 public extension Writer {
-
-
-
-
 	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Array<Output>> where ParameterType == Array<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Output>> where ParameterType == Effect<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Output>> where ParameterType == Future<Input> {
         return map { $0.map(transform) }
     }
-
-
-
 	func mapT <Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Optional<Output>> where ParameterType == Optional<Input> {
         return map { $0.fmap(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Output>> where ParameterType == Reader<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Output>> where ParameterType == State<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
         return map { $0.map(transform) }
     }
-
-
-
-	func mapT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
+	func mapT <Secondary,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
         return map { $0.map(transform) }
     }
 }
-
-
-
diff --git a/Sources/FunctionalKit/FunctorTransformers3.generated.swift b/Sources/FunctionalKit/FunctorTransformers3.generated.swift
index 89e4447..607a838 100644
--- a/Sources/FunctionalKit/FunctorTransformers3.generated.swift
+++ b/Sources/FunctionalKit/FunctorTransformers3.generated.swift
@@ -3,3648 +3,1555 @@
 
 
 
-
-
-
-
-
-
 public extension Array {
-
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Array<Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Array<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Array<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Array<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Array<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Result<Output,Secondary3>>> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Result<Output,Secondary3>>> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Array<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Array<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Array<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Array<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Array<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Result<Output,Secondary3>>> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<Effect<Output>,Secondary2>> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<Future<Output>,Secondary2>> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<Reader<Secondary3,Output>,Secondary2>> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Result<State<Secondary3,Output>,Secondary2>> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Result<Output,Secondary3>>> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Array<Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Array<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
-
 public extension Effect {
-
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Result<Output,Secondary3>>> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Result<Output,Secondary3>>> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Result<Output,Secondary3>>> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Effect<Output>,Secondary2>> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Future<Output>,Secondary2>> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Reader<Secondary3,Output>,Secondary2>> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<State<Secondary3,Output>,Secondary2>> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Result<Output,Secondary3>>> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Effect<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
-
 public extension Future {
-
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Result<Output,Secondary3>>> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Result<Output,Secondary3>>> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Result<Output,Secondary3>>> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Effect<Output>,Secondary2>> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Future<Output>,Secondary2>> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Reader<Secondary3,Output>,Secondary2>> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<State<Secondary3,Output>,Secondary2>> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Result<Output,Secondary3>>> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Future<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
-
 public extension Optional {
-
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Optional<Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Optional<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Optional<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Optional<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Optional<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Result<Output,Secondary3>>> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Result<Output,Secondary3>>> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Optional<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Optional<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
 		return fmap { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Optional<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Optional<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Optional<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return fmap { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Result<Output,Secondary3>>> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<Effect<Output>,Secondary2>> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<Future<Output>,Secondary2>> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<Reader<Secondary3,Output>,Secondary2>> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Result<State<Secondary3,Output>,Secondary2>> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Result<Output,Secondary3>>> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return fmap { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Optional<Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Optional<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return fmap { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
-
 public extension Reader {
-
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Result<Output,Secondary3>>> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Result<Output,Secondary3>>> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Result<Output,Secondary3>>> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Effect<Output>,Secondary2>> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Future<Output>,Secondary2>> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Reader<Secondary3,Output>,Secondary2>> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<State<Secondary3,Output>,Secondary2>> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Result<Output,Secondary3>>> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Reader<Environment,Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
-
 public extension Result {
-
-
-
-
-
-	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
+	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Array<Array<Output>>,Failure> where ParameterType == Array<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Array<Effect<Output>>,Failure> where ParameterType == Array<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Array<Future<Output>>,Failure> where ParameterType == Array<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
+	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Array<Optional<Output>>,Failure> where ParameterType == Array<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Array<Reader<Secondary3,Output>>,Failure> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Array<Result<Output,Secondary3>>,Failure> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Array<State<Secondary3,Output>>,Failure> where ParameterType == Array<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Array<Writer<Secondary3,Output>>,Failure> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Array<Output>>,Failure> where ParameterType == Effect<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Effect<Output>>,Failure> where ParameterType == Effect<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Future<Output>>,Failure> where ParameterType == Effect<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Optional<Output>>,Failure> where ParameterType == Effect<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Reader<Secondary3,Output>>,Failure> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Result<Output,Secondary3>>,Failure> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<State<Secondary3,Output>>,Failure> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Effect<Writer<Secondary3,Output>>,Failure> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Array<Output>>,Failure> where ParameterType == Future<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Effect<Output>>,Failure> where ParameterType == Future<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Future<Output>>,Failure> where ParameterType == Future<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Optional<Output>>,Failure> where ParameterType == Future<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Reader<Secondary3,Output>>,Failure> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Result<Output,Secondary3>>,Failure> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<State<Secondary3,Output>>,Failure> where ParameterType == Future<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Future<Writer<Secondary3,Output>>,Failure> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
+	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Optional<Array<Output>>,Failure> where ParameterType == Optional<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Optional<Effect<Output>>,Failure> where ParameterType == Optional<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
+	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Optional<Future<Output>>,Failure> where ParameterType == Optional<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
+	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Result<Optional<Optional<Output>>,Failure> where ParameterType == Optional<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Optional<Reader<Secondary3,Output>>,Failure> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Optional<Result<Output,Secondary3>>,Failure> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Optional<State<Secondary3,Output>>,Failure> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Result<Optional<Writer<Secondary3,Output>>,Failure> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,Array<Output>>,Failure> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,Effect<Output>>,Failure> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,Future<Output>>,Failure> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,Optional<Output>>,Failure> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,Reader<Secondary3,Output>>,Failure> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,Result<Output,Secondary3>>,Failure> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,State<Secondary3,Output>>,Failure> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Reader<Secondary2,Writer<Secondary3,Output>>,Failure> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Result<Array<Output>,Secondary2>,Failure> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Result<Effect<Output>,Secondary2>,Failure> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Result<Future<Output>,Secondary2>,Failure> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Result<Optional<Output>,Secondary2>,Failure> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Result<Reader<Secondary3,Output>,Secondary2>,Failure> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Result<Result<Output,Secondary3>,Secondary2>,Failure> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Result<State<Secondary3,Output>,Secondary2>,Failure> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Result<Writer<Secondary3,Output>,Secondary2>,Failure> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,Array<Output>>,Failure> where ParameterType == State<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,Effect<Output>>,Failure> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,Future<Output>>,Failure> where ParameterType == State<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,Optional<Output>>,Failure> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,Reader<Secondary3,Output>>,Failure> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,Result<Output,Secondary3>>,Failure> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,State<Secondary3,Output>>,Failure> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<State<Secondary2,Writer<Secondary3,Output>>,Failure> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Writer<Secondary2,Array<Output>>,Failure> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Writer<Secondary2,Effect<Output>>,Failure> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Writer<Secondary2,Future<Output>>,Failure> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Writer<Secondary2,Optional<Output>>,Failure> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Writer<Secondary2,Reader<Secondary3,Output>>,Failure> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Writer<Secondary2,Result<Output,Secondary3>>,Failure> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Failure,Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Result<Writer<Secondary2,State<Secondary3,Output>>,Failure> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Failure,Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Result<Writer<Secondary2,Writer<Secondary3,Output>>,Failure> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
-
 public extension State {
-
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
-		return map { $0.fmap { $0.map(transform) } }
-	}
-
-
-
-
+		return map { $0.fmap { $0.map(transform) } }
+	}
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Result<Output,Secondary3>>> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Result<Output,Secondary3>>> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Result<Output,Secondary3>>> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Effect<Output>,Secondary2>> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Future<Output>,Secondary2>> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Reader<Secondary3,Output>,Secondary2>> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<State<Secondary3,Output>,Secondary2>> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Result<Output,Secondary3>>> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> State<Model,Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
-
-public extension Writer {
-
-
-
-
-
+public extension Writer {
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Array<Array<Output>>> where ParameterType == Array<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Array<Effect<Output>>> where ParameterType == Array<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Array<Future<Output>>> where ParameterType == Array<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Array<Reader<Secondary3,Output>>> where ParameterType == Array<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Array<State<Secondary3,Output>>> where ParameterType == Array<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Array<Output>>> where ParameterType == Effect<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Effect<Output>>> where ParameterType == Effect<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Future<Output>>> where ParameterType == Effect<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Reader<Secondary3,Output>>> where ParameterType == Effect<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Result<Secondary3,Output>>> where ParameterType == Effect<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Result<Output,Secondary3>>> where ParameterType == Effect<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<State<Secondary3,Output>>> where ParameterType == Effect<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Effect<Writer<Secondary3,Output>>> where ParameterType == Effect<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Array<Output>>> where ParameterType == Future<Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Effect<Output>>> where ParameterType == Future<Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Future<Output>>> where ParameterType == Future<Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Optional<Output>>> where ParameterType == Future<Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Reader<Secondary3,Output>>> where ParameterType == Future<Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Result<Secondary3,Output>>> where ParameterType == Future<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Result<Output,Secondary3>>> where ParameterType == Future<Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<State<Secondary3,Output>>> where ParameterType == Future<State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Future<Writer<Secondary3,Output>>> where ParameterType == Future<Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Optional<Effect<Output>>> where ParameterType == Optional<Effect<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Optional<Future<Output>>> where ParameterType == Optional<Future<Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>>  {
 		return map { $0.fmap { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Optional<Reader<Secondary3,Output>>> where ParameterType == Optional<Reader<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Optional<State<Secondary3,Output>>> where ParameterType == Optional<State<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>>  {
 		return map { $0.fmap { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Array<Output>>> where ParameterType == Reader<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Effect<Output>>> where ParameterType == Reader<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Future<Output>>> where ParameterType == Reader<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Optional<Output>>> where ParameterType == Reader<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Result<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Result<Output,Secondary3>>> where ParameterType == Reader<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,State<Secondary3,Output>>> where ParameterType == Reader<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Reader<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Reader<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<Secondary2,Effect<Output>>> where ParameterType == Result<Secondary2,Effect<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<Effect<Output>,Secondary2>> where ParameterType == Result<Effect<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<Secondary2,Future<Output>>> where ParameterType == Result<Secondary2,Future<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<Future<Output>,Secondary2>> where ParameterType == Result<Future<Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>>  {
+	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Result<Secondary2,Reader<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<Reader<Secondary3,Output>,Secondary2>> where ParameterType == Result<Reader<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<Secondary2,State<Secondary3,Output>>> where ParameterType == Result<Secondary2,State<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Result<State<Secondary3,Output>,Secondary2>> where ParameterType == Result<State<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Array<Output>>> where ParameterType == State<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Effect<Output>>> where ParameterType == State<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Future<Output>>> where ParameterType == State<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Optional<Output>>> where ParameterType == State<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Reader<Secondary3,Output>>> where ParameterType == State<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Result<Secondary3,Output>>> where ParameterType == State<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Result<Output,Secondary3>>> where ParameterType == State<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,State<Secondary3,Output>>> where ParameterType == State<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,State<Secondary2,Writer<Secondary3,Output>>> where ParameterType == State<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Writer<Secondary2,Effect<Output>>> where ParameterType == Writer<Secondary2,Effect<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Writer<Secondary2,Future<Output>>> where ParameterType == Writer<Secondary2,Future<Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>>  {
 		return map { $0.map { $0.fmap(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Writer<Secondary2,Reader<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Reader<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
-	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>>  {
+	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Output) -> Writer<Log,Writer<Secondary2,State<Secondary3,Output>>> where ParameterType == Writer<Secondary2,State<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
-
-
-
-
 	func mapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Output) -> Writer<Log,Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>>  {
 		return map { $0.map { $0.map(transform) } }
 	}
 }
-
-
-
diff --git a/Sources/FunctionalKit/MonadTransformers2.generated.swift b/Sources/FunctionalKit/MonadTransformers2.generated.swift
index 066fa30..45f08ea 100644
--- a/Sources/FunctionalKit/MonadTransformers2.generated.swift
+++ b/Sources/FunctionalKit/MonadTransformers2.generated.swift
@@ -3,283 +3,157 @@
 
 
 
-
-
-
-
-
-
-
-
 public extension Array {
-
-
-
-
 	func flatMapT <Input,Output> (_ transform: (Input) -> Array<Array<Output>>) -> Array<Array<Output>> where ParameterType == Array<Input> {
         return flatMap { (value) -> Array<Array<Output>> in
 			value.traverse(transform).fmap { $0.flatMap(f.identity) }
         }
     }
-
-
-
 	func flatMapT <Input,Output> (_ transform: (Input) -> Array<Optional<Output>>) -> Array<Optional<Output>> where ParameterType == Optional<Input> {
         return flatMap { (value) -> Array<Optional<Output>> in
 			value.traverse(transform).fmap { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Secondary2,Output>>) -> Array<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
-        return flatMap { (value) -> Array<Result<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Array<Result<Output,Secondary>>) -> Array<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
+        return flatMap { (value) -> Array<Result<Output,Secondary>> in
 			value.traverse(transform).fmap { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Writer<Secondary2,Output>>) -> Array<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
-        return flatMap { (value) -> Array<Writer<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Array<Writer<Secondary,Output>>) -> Array<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
+        return flatMap { (value) -> Array<Writer<Secondary,Output>> in
 			value.traverse(transform).fmap { $0.joined() }
         }
     }
 }
-
-
-
-
 public extension Effect {
-
-
-
-
 	func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Effect<Array<Output>>) -> Effect<Array<Output>> where ParameterType == Array<Input> {
         return flatMap { (value) -> Effect<Array<Output>> in
 			value.traverse(transform).map { $0.flatMap(f.identity) }
         }
     }
-
-
-
 	func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Effect<Optional<Output>>) -> Effect<Optional<Output>> where ParameterType == Optional<Input> {
         return flatMap { (value) -> Effect<Optional<Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Secondary2,Output>>) -> Effect<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
-        return flatMap { (value) -> Effect<Result<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Output,Secondary>>) -> Effect<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
+        return flatMap { (value) -> Effect<Result<Output,Secondary>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Writer<Secondary2,Output>>) -> Effect<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
-        return flatMap { (value) -> Effect<Writer<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Effect<Writer<Secondary,Output>>) -> Effect<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
+        return flatMap { (value) -> Effect<Writer<Secondary,Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
 }
-
-
-
-
 public extension Future {
-
-
-
-
 	func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Future<Array<Output>>) -> Future<Array<Output>> where ParameterType == Array<Input> {
         return flatMap { (value) -> Future<Array<Output>> in
 			value.traverse(transform).map { $0.flatMap(f.identity) }
         }
     }
-
-
-
 	func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Future<Optional<Output>>) -> Future<Optional<Output>> where ParameterType == Optional<Input> {
         return flatMap { (value) -> Future<Optional<Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Secondary2,Output>>) -> Future<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
-        return flatMap { (value) -> Future<Result<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Output,Secondary>>) -> Future<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
+        return flatMap { (value) -> Future<Result<Output,Secondary>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Writer<Secondary2,Output>>) -> Future<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
-        return flatMap { (value) -> Future<Writer<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Future<Writer<Secondary,Output>>) -> Future<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
+        return flatMap { (value) -> Future<Writer<Secondary,Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
 }
-
-
-
-
 public extension Optional {
-
-
-
-
 	func flatMapT <Input,Output> (_ transform: (Input) -> Optional<Array<Output>>) -> Optional<Array<Output>> where ParameterType == Array<Input> {
         return flatMap { (value) -> Optional<Array<Output>> in
 			value.traverse(transform).fmap { $0.flatMap(f.identity) }
         }
     }
-
-
-
 	func flatMapT <Input,Output> (_ transform: (Input) -> Optional<Optional<Output>>) -> Optional<Optional<Output>> where ParameterType == Optional<Input> {
         return flatMap { (value) -> Optional<Optional<Output>> in
 			value.traverse(transform).fmap { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Secondary2,Output>>) -> Optional<Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
-        return flatMap { (value) -> Optional<Result<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Optional<Result<Output,Secondary>>) -> Optional<Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
+        return flatMap { (value) -> Optional<Result<Output,Secondary>> in
 			value.traverse(transform).fmap { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Writer<Secondary2,Output>>) -> Optional<Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
-        return flatMap { (value) -> Optional<Writer<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Optional<Writer<Secondary,Output>>) -> Optional<Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
+        return flatMap { (value) -> Optional<Writer<Secondary,Output>> in
 			value.traverse(transform).fmap { $0.joined() }
         }
     }
 }
-
-
-
-
 public extension Result {
-
-
-
-
-	func flatMapT <Input,Output> (_ transform: (Input) -> Result<Failure,Array<Output>>) -> Result<Failure,Array<Output>> where ParameterType == Array<Input> {
-        return flatMap { (value) -> Result<Failure,Array<Output>> in
+	func flatMapT <Input,Output> (_ transform: (Input) -> Result<Array<Output>,Failure>) -> Result<Array<Output>,Failure> where ParameterType == Array<Input> {
+        return flatMap { (value) -> Result<Array<Output>,Failure> in
 			value.traverse(transform).map { $0.flatMap(f.identity) }
         }
     }
-
-
-
-	func flatMapT <Input,Output> (_ transform: (Input) -> Result<Failure,Optional<Output>>) -> Result<Failure,Optional<Output>> where ParameterType == Optional<Input> {
-        return flatMap { (value) -> Result<Failure,Optional<Output>> in
+	func flatMapT <Input,Output> (_ transform: (Input) -> Result<Optional<Output>,Failure>) -> Result<Optional<Output>,Failure> where ParameterType == Optional<Input> {
+        return flatMap { (value) -> Result<Optional<Output>,Failure> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Result<Secondary2,Output>>) -> Result<Failure,Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
-        return flatMap { (value) -> Result<Failure,Result<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Result<Result<Output,Secondary>,Failure>) -> Result<Result<Output,Secondary>,Failure> where ParameterType == Result<Input,Secondary> {
+        return flatMap { (value) -> Result<Result<Output,Secondary>,Failure> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Writer<Secondary2,Output>>) -> Result<Failure,Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
-        return flatMap { (value) -> Result<Failure,Writer<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Result<Writer<Secondary,Output>,Failure>) -> Result<Writer<Secondary,Output>,Failure> where ParameterType == Writer<Secondary,Input> {
+        return flatMap { (value) -> Result<Writer<Secondary,Output>,Failure> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
 }
-
-
-
-
 public extension State {
-
-
-
-
 	func flatMapT <Input,Output> (_ transform: @escaping (Input) -> State<Model,Array<Output>>) -> State<Model,Array<Output>> where ParameterType == Array<Input> {
         return flatMap { (value) -> State<Model,Array<Output>> in
 			value.traverse(transform).map { $0.flatMap(f.identity) }
         }
     }
-
-
-
 	func flatMapT <Input,Output> (_ transform: @escaping (Input) -> State<Model,Optional<Output>>) -> State<Model,Optional<Output>> where ParameterType == Optional<Input> {
         return flatMap { (value) -> State<Model,Optional<Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Secondary2,Output>>) -> State<Model,Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
-        return flatMap { (value) -> State<Model,Result<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Output,Secondary>>) -> State<Model,Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
+        return flatMap { (value) -> State<Model,Result<Output,Secondary>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Writer<Secondary2,Output>>) -> State<Model,Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
-        return flatMap { (value) -> State<Model,Writer<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> State<Model,Writer<Secondary,Output>>) -> State<Model,Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
+        return flatMap { (value) -> State<Model,Writer<Secondary,Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
 }
-
-
-
-
 public extension Writer {
-
-
-
-
 	func flatMapT <Input,Output> (_ transform: (Input) -> Writer<Log,Array<Output>>) -> Writer<Log,Array<Output>> where ParameterType == Array<Input> {
         return flatMap { (value) -> Writer<Log,Array<Output>> in
 			value.traverse(transform).map { $0.flatMap(f.identity) }
         }
     }
-
-
-
 	func flatMapT <Input,Output> (_ transform: (Input) -> Writer<Log,Optional<Output>>) -> Writer<Log,Optional<Output>> where ParameterType == Optional<Input> {
         return flatMap { (value) -> Writer<Log,Optional<Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Secondary2,Output>>) -> Writer<Log,Result<Secondary2,Output>> where ParameterType == Result<Secondary2,Input> {
-        return flatMap { (value) -> Writer<Log,Result<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Output,Secondary>>) -> Writer<Log,Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
+        return flatMap { (value) -> Writer<Log,Result<Output,Secondary>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
-
-
-
-	func flatMapT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Writer<Secondary2,Output>>) -> Writer<Log,Writer<Secondary2,Output>> where ParameterType == Writer<Secondary2,Input> {
-        return flatMap { (value) -> Writer<Log,Writer<Secondary2,Output>> in
+	func flatMapT <Secondary,Input,Output> (_ transform: (Input) -> Writer<Log,Writer<Secondary,Output>>) -> Writer<Log,Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
+        return flatMap { (value) -> Writer<Log,Writer<Secondary,Output>> in
 			value.traverse(transform).map { $0.joined() }
         }
     }
 }
-
-
-
diff --git a/Sources/FunctionalKit/MonadTransformers3.generated.swift b/Sources/FunctionalKit/MonadTransformers3.generated.swift
index 15b2e7f..99bd0e6 100644
--- a/Sources/FunctionalKit/MonadTransformers3.generated.swift
+++ b/Sources/FunctionalKit/MonadTransformers3.generated.swift
@@ -3,155 +3,82 @@
 
 
 
-
-
-
-
-
-
-
-
 public extension Array {
-
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Array<Array<Array<Output>>>) -> Array<Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
 		return flatMapT { (value) -> Array<Array<Array<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Array<Array<Optional<Output>>>) -> Array<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
 		return flatMapT { (value) -> Array<Array<Optional<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Array<Array<Result<Secondary3,Output>>>) -> Array<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Array<Array<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Array<Array<Result<Output,Secondary3>>>) -> Array<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Array<Array<Result<Output,Secondary3>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Array<Array<Writer<Secondary3,Output>>>) -> Array<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Array<Array<Writer<Secondary3,Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Array<Optional<Array<Output>>>) -> Array<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
 		return flatMapT { (value) -> Array<Optional<Array<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Array<Optional<Optional<Output>>>) -> Array<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
 		return flatMapT { (value) -> Array<Optional<Optional<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Array<Optional<Result<Secondary3,Output>>>) -> Array<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Array<Optional<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Array<Optional<Result<Output,Secondary3>>>) -> Array<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Array<Optional<Result<Output,Secondary3>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Array<Optional<Writer<Secondary3,Output>>>) -> Array<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Array<Optional<Writer<Secondary3,Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Secondary2,Array<Output>>>) -> Array<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> Array<Result<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Array<Output>,Secondary2>>) -> Array<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2> {
+		return flatMapT { (value) -> Array<Result<Array<Output>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Secondary2,Optional<Output>>>) -> Array<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> Array<Result<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Optional<Output>,Secondary2>>) -> Array<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2> {
+		return flatMapT { (value) -> Array<Result<Optional<Output>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Secondary2,Result<Secondary3,Output>>>) -> Array<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Array<Result<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Result<Output,Secondary3>,Secondary2>>) -> Array<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2> {
+		return flatMapT { (value) -> Array<Result<Result<Output,Secondary3>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Secondary2,Writer<Secondary3,Output>>>) -> Array<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Array<Result<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Array<Result<Writer<Secondary3,Output>,Secondary2>>) -> Array<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2> {
+		return flatMapT { (value) -> Array<Result<Writer<Secondary3,Output>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Writer<Secondary2,Array<Output>>>) -> Array<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>> {
 		return flatMapT { (value) -> Array<Writer<Secondary2,Array<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Array<Writer<Secondary2,Optional<Output>>>) -> Array<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>> {
 		return flatMapT { (value) -> Array<Writer<Secondary2,Optional<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Array<Writer<Secondary2,Result<Secondary3,Output>>>) -> Array<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Array<Writer<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Array<Writer<Secondary2,Result<Output,Secondary3>>>) -> Array<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Array<Writer<Secondary2,Result<Output,Secondary3>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Array<Writer<Secondary2,Writer<Secondary3,Output>>>) -> Array<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Array<Writer<Secondary2,Writer<Secondary3,Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
@@ -161,148 +88,82 @@ public extension Array {
 
 
 
-
 public extension Effect {
-
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Effect<Array<Array<Output>>>) -> Effect<Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
 		return flatMapT { (value) -> Effect<Array<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Effect<Array<Optional<Output>>>) -> Effect<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
 		return flatMapT { (value) -> Effect<Array<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Effect<Array<Result<Secondary3,Output>>>) -> Effect<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Effect<Array<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Effect<Array<Result<Output,Secondary3>>>) -> Effect<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Effect<Array<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Effect<Array<Writer<Secondary3,Output>>>) -> Effect<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Effect<Array<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Effect<Optional<Array<Output>>>) -> Effect<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
 		return flatMapT { (value) -> Effect<Optional<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Effect<Optional<Optional<Output>>>) -> Effect<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
 		return flatMapT { (value) -> Effect<Optional<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Effect<Optional<Result<Secondary3,Output>>>) -> Effect<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Effect<Optional<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Effect<Optional<Result<Output,Secondary3>>>) -> Effect<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Effect<Optional<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Effect<Optional<Writer<Secondary3,Output>>>) -> Effect<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Effect<Optional<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Secondary2,Array<Output>>>) -> Effect<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> Effect<Result<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Array<Output>,Secondary2>>) -> Effect<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2> {
+		return flatMapT { (value) -> Effect<Result<Array<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Secondary2,Optional<Output>>>) -> Effect<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> Effect<Result<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Optional<Output>,Secondary2>>) -> Effect<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2> {
+		return flatMapT { (value) -> Effect<Result<Optional<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Secondary2,Result<Secondary3,Output>>>) -> Effect<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Effect<Result<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Result<Output,Secondary3>,Secondary2>>) -> Effect<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2> {
+		return flatMapT { (value) -> Effect<Result<Result<Output,Secondary3>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Secondary2,Writer<Secondary3,Output>>>) -> Effect<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Effect<Result<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Result<Writer<Secondary3,Output>,Secondary2>>) -> Effect<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2> {
+		return flatMapT { (value) -> Effect<Result<Writer<Secondary3,Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Writer<Secondary2,Array<Output>>>) -> Effect<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>> {
 		return flatMapT { (value) -> Effect<Writer<Secondary2,Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Writer<Secondary2,Optional<Output>>>) -> Effect<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>> {
 		return flatMapT { (value) -> Effect<Writer<Secondary2,Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Writer<Secondary2,Result<Secondary3,Output>>>) -> Effect<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Effect<Writer<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Writer<Secondary2,Result<Output,Secondary3>>>) -> Effect<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Effect<Writer<Secondary2,Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Effect<Writer<Secondary2,Writer<Secondary3,Output>>>) -> Effect<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Effect<Writer<Secondary2,Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
@@ -312,148 +173,82 @@ public extension Effect {
 
 
 
-
 public extension Future {
-
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Future<Array<Array<Output>>>) -> Future<Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
 		return flatMapT { (value) -> Future<Array<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Future<Array<Optional<Output>>>) -> Future<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
 		return flatMapT { (value) -> Future<Array<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Future<Array<Result<Secondary3,Output>>>) -> Future<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Future<Array<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Future<Array<Result<Output,Secondary3>>>) -> Future<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Future<Array<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Future<Array<Writer<Secondary3,Output>>>) -> Future<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Future<Array<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Future<Optional<Array<Output>>>) -> Future<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
 		return flatMapT { (value) -> Future<Optional<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Future<Optional<Optional<Output>>>) -> Future<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
 		return flatMapT { (value) -> Future<Optional<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Future<Optional<Result<Secondary3,Output>>>) -> Future<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Future<Optional<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Future<Optional<Result<Output,Secondary3>>>) -> Future<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Future<Optional<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Future<Optional<Writer<Secondary3,Output>>>) -> Future<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Future<Optional<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Secondary2,Array<Output>>>) -> Future<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> Future<Result<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Array<Output>,Secondary2>>) -> Future<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2> {
+		return flatMapT { (value) -> Future<Result<Array<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Secondary2,Optional<Output>>>) -> Future<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> Future<Result<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Optional<Output>,Secondary2>>) -> Future<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2> {
+		return flatMapT { (value) -> Future<Result<Optional<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Secondary2,Result<Secondary3,Output>>>) -> Future<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Future<Result<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Result<Output,Secondary3>,Secondary2>>) -> Future<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2> {
+		return flatMapT { (value) -> Future<Result<Result<Output,Secondary3>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Secondary2,Writer<Secondary3,Output>>>) -> Future<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Future<Result<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Result<Writer<Secondary3,Output>,Secondary2>>) -> Future<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2> {
+		return flatMapT { (value) -> Future<Result<Writer<Secondary3,Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Writer<Secondary2,Array<Output>>>) -> Future<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>> {
 		return flatMapT { (value) -> Future<Writer<Secondary2,Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Writer<Secondary2,Optional<Output>>>) -> Future<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>> {
 		return flatMapT { (value) -> Future<Writer<Secondary2,Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Writer<Secondary2,Result<Secondary3,Output>>>) -> Future<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Future<Writer<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Writer<Secondary2,Result<Output,Secondary3>>>) -> Future<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Future<Writer<Secondary2,Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Future<Writer<Secondary2,Writer<Secondary3,Output>>>) -> Future<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Future<Writer<Secondary2,Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
@@ -463,148 +258,82 @@ public extension Future {
 
 
 
-
 public extension Optional {
-
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Optional<Array<Array<Output>>>) -> Optional<Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
 		return flatMapT { (value) -> Optional<Array<Array<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Optional<Array<Optional<Output>>>) -> Optional<Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
 		return flatMapT { (value) -> Optional<Array<Optional<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Optional<Array<Result<Secondary3,Output>>>) -> Optional<Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Optional<Array<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Optional<Array<Result<Output,Secondary3>>>) -> Optional<Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Optional<Array<Result<Output,Secondary3>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Optional<Array<Writer<Secondary3,Output>>>) -> Optional<Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Optional<Array<Writer<Secondary3,Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Optional<Optional<Array<Output>>>) -> Optional<Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
 		return flatMapT { (value) -> Optional<Optional<Array<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Optional<Optional<Optional<Output>>>) -> Optional<Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
 		return flatMapT { (value) -> Optional<Optional<Optional<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Optional<Optional<Result<Secondary3,Output>>>) -> Optional<Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Optional<Optional<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Optional<Optional<Result<Output,Secondary3>>>) -> Optional<Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Optional<Optional<Result<Output,Secondary3>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Optional<Optional<Writer<Secondary3,Output>>>) -> Optional<Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Optional<Optional<Writer<Secondary3,Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Secondary2,Array<Output>>>) -> Optional<Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> Optional<Result<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Array<Output>,Secondary2>>) -> Optional<Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2> {
+		return flatMapT { (value) -> Optional<Result<Array<Output>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Secondary2,Optional<Output>>>) -> Optional<Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> Optional<Result<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Optional<Output>,Secondary2>>) -> Optional<Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2> {
+		return flatMapT { (value) -> Optional<Result<Optional<Output>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Secondary2,Result<Secondary3,Output>>>) -> Optional<Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Optional<Result<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Result<Output,Secondary3>,Secondary2>>) -> Optional<Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2> {
+		return flatMapT { (value) -> Optional<Result<Result<Output,Secondary3>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Secondary2,Writer<Secondary3,Output>>>) -> Optional<Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Optional<Result<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Optional<Result<Writer<Secondary3,Output>,Secondary2>>) -> Optional<Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2> {
+		return flatMapT { (value) -> Optional<Result<Writer<Secondary3,Output>,Secondary2>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Writer<Secondary2,Array<Output>>>) -> Optional<Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>> {
 		return flatMapT { (value) -> Optional<Writer<Secondary2,Array<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Optional<Writer<Secondary2,Optional<Output>>>) -> Optional<Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>> {
 		return flatMapT { (value) -> Optional<Writer<Secondary2,Optional<Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Optional<Writer<Secondary2,Result<Secondary3,Output>>>) -> Optional<Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Optional<Writer<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Optional<Writer<Secondary2,Result<Output,Secondary3>>>) -> Optional<Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Optional<Writer<Secondary2,Result<Output,Secondary3>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Optional<Writer<Secondary2,Writer<Secondary3,Output>>>) -> Optional<Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Optional<Writer<Secondary2,Writer<Secondary3,Output>>> in
 			value.traverse(transform).fmap { $0.traverse(f.identity) }.mapT { $0.joined() }
@@ -614,150 +343,84 @@ public extension Optional {
 
 
 
-
 public extension Result {
-
-
-
-
-
-	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Failure,Array<Array<Output>>>) -> Result<Failure,Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
-		return flatMapT { (value) -> Result<Failure,Array<Array<Output>>> in
+	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Array<Array<Output>>,Failure>) -> Result<Array<Array<Output>>,Failure> where ParameterType == Array<Array<Input>> {
+		return flatMapT { (value) -> Result<Array<Array<Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Failure,Array<Optional<Output>>>) -> Result<Failure,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
-		return flatMapT { (value) -> Result<Failure,Array<Optional<Output>>> in
+	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Array<Optional<Output>>,Failure>) -> Result<Array<Optional<Output>>,Failure> where ParameterType == Array<Optional<Input>> {
+		return flatMapT { (value) -> Result<Array<Optional<Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Failure,Array<Result<Secondary3,Output>>>) -> Result<Failure,Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Array<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Array<Result<Output,Secondary3>>,Failure>) -> Result<Array<Result<Output,Secondary3>>,Failure> where ParameterType == Array<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Result<Array<Result<Output,Secondary3>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Failure,Array<Writer<Secondary3,Output>>>) -> Result<Failure,Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Array<Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Array<Writer<Secondary3,Output>>,Failure>) -> Result<Array<Writer<Secondary3,Output>>,Failure> where ParameterType == Array<Writer<Secondary3,Input>> {
+		return flatMapT { (value) -> Result<Array<Writer<Secondary3,Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Failure,Optional<Array<Output>>>) -> Result<Failure,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
-		return flatMapT { (value) -> Result<Failure,Optional<Array<Output>>> in
+	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Optional<Array<Output>>,Failure>) -> Result<Optional<Array<Output>>,Failure> where ParameterType == Optional<Array<Input>> {
+		return flatMapT { (value) -> Result<Optional<Array<Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Failure,Optional<Optional<Output>>>) -> Result<Failure,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
-		return flatMapT { (value) -> Result<Failure,Optional<Optional<Output>>> in
+	func flatMapTT <Input,Output> (_ transform: (Input) -> Result<Optional<Optional<Output>>,Failure>) -> Result<Optional<Optional<Output>>,Failure> where ParameterType == Optional<Optional<Input>> {
+		return flatMapT { (value) -> Result<Optional<Optional<Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Failure,Optional<Result<Secondary3,Output>>>) -> Result<Failure,Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Optional<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Optional<Result<Output,Secondary3>>,Failure>) -> Result<Optional<Result<Output,Secondary3>>,Failure> where ParameterType == Optional<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Result<Optional<Result<Output,Secondary3>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Failure,Optional<Writer<Secondary3,Output>>>) -> Result<Failure,Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Optional<Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Result<Optional<Writer<Secondary3,Output>>,Failure>) -> Result<Optional<Writer<Secondary3,Output>>,Failure> where ParameterType == Optional<Writer<Secondary3,Input>> {
+		return flatMapT { (value) -> Result<Optional<Writer<Secondary3,Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Result<Secondary2,Array<Output>>>) -> Result<Failure,Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> Result<Failure,Result<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Result<Array<Output>,Secondary2>,Failure>) -> Result<Result<Array<Output>,Secondary2>,Failure> where ParameterType == Result<Array<Input>,Secondary2> {
+		return flatMapT { (value) -> Result<Result<Array<Output>,Secondary2>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Result<Secondary2,Optional<Output>>>) -> Result<Failure,Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> Result<Failure,Result<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Result<Optional<Output>,Secondary2>,Failure>) -> Result<Result<Optional<Output>,Secondary2>,Failure> where ParameterType == Result<Optional<Input>,Secondary2> {
+		return flatMapT { (value) -> Result<Result<Optional<Output>,Secondary2>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Result<Secondary2,Result<Secondary3,Output>>>) -> Result<Failure,Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Result<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Result<Result<Output,Secondary3>,Secondary2>,Failure>) -> Result<Result<Result<Output,Secondary3>,Secondary2>,Failure> where ParameterType == Result<Result<Input,Secondary3>,Secondary2> {
+		return flatMapT { (value) -> Result<Result<Result<Output,Secondary3>,Secondary2>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Result<Secondary2,Writer<Secondary3,Output>>>) -> Result<Failure,Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Result<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Result<Writer<Secondary3,Output>,Secondary2>,Failure>) -> Result<Result<Writer<Secondary3,Output>,Secondary2>,Failure> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2> {
+		return flatMapT { (value) -> Result<Result<Writer<Secondary3,Output>,Secondary2>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Writer<Secondary2,Array<Output>>>) -> Result<Failure,Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> Result<Failure,Writer<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Writer<Secondary2,Array<Output>>,Failure>) -> Result<Writer<Secondary2,Array<Output>>,Failure> where ParameterType == Writer<Secondary2,Array<Input>> {
+		return flatMapT { (value) -> Result<Writer<Secondary2,Array<Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Writer<Secondary2,Optional<Output>>>) -> Result<Failure,Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> Result<Failure,Writer<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Result<Writer<Secondary2,Optional<Output>>,Failure>) -> Result<Writer<Secondary2,Optional<Output>>,Failure> where ParameterType == Writer<Secondary2,Optional<Input>> {
+		return flatMapT { (value) -> Result<Writer<Secondary2,Optional<Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Writer<Secondary2,Result<Secondary3,Output>>>) -> Result<Failure,Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Writer<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Writer<Secondary2,Result<Output,Secondary3>>,Failure>) -> Result<Writer<Secondary2,Result<Output,Secondary3>>,Failure> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Result<Writer<Secondary2,Result<Output,Secondary3>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Failure,Writer<Secondary2,Writer<Secondary3,Output>>>) -> Result<Failure,Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Result<Failure,Writer<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Result<Writer<Secondary2,Writer<Secondary3,Output>>,Failure>) -> Result<Writer<Secondary2,Writer<Secondary3,Output>>,Failure> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
+		return flatMapT { (value) -> Result<Writer<Secondary2,Writer<Secondary3,Output>>,Failure> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
@@ -765,148 +428,82 @@ public extension Result {
 
 
 
-
 public extension State {
-
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> State<Model,Array<Array<Output>>>) -> State<Model,Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
 		return flatMapT { (value) -> State<Model,Array<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> State<Model,Array<Optional<Output>>>) -> State<Model,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
 		return flatMapT { (value) -> State<Model,Array<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> State<Model,Array<Result<Secondary3,Output>>>) -> State<Model,Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> State<Model,Array<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> State<Model,Array<Result<Output,Secondary3>>>) -> State<Model,Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> State<Model,Array<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> State<Model,Array<Writer<Secondary3,Output>>>) -> State<Model,Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> State<Model,Array<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> State<Model,Optional<Array<Output>>>) -> State<Model,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
 		return flatMapT { (value) -> State<Model,Optional<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> State<Model,Optional<Optional<Output>>>) -> State<Model,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
 		return flatMapT { (value) -> State<Model,Optional<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> State<Model,Optional<Result<Secondary3,Output>>>) -> State<Model,Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> State<Model,Optional<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> State<Model,Optional<Result<Output,Secondary3>>>) -> State<Model,Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> State<Model,Optional<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> State<Model,Optional<Writer<Secondary3,Output>>>) -> State<Model,Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> State<Model,Optional<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Secondary2,Array<Output>>>) -> State<Model,Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> State<Model,Result<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Array<Output>,Secondary2>>) -> State<Model,Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2> {
+		return flatMapT { (value) -> State<Model,Result<Array<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Secondary2,Optional<Output>>>) -> State<Model,Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> State<Model,Result<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Optional<Output>,Secondary2>>) -> State<Model,Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2> {
+		return flatMapT { (value) -> State<Model,Result<Optional<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Secondary2,Result<Secondary3,Output>>>) -> State<Model,Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> State<Model,Result<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Result<Output,Secondary3>,Secondary2>>) -> State<Model,Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2> {
+		return flatMapT { (value) -> State<Model,Result<Result<Output,Secondary3>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Secondary2,Writer<Secondary3,Output>>>) -> State<Model,Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> State<Model,Result<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Result<Writer<Secondary3,Output>,Secondary2>>) -> State<Model,Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2> {
+		return flatMapT { (value) -> State<Model,Result<Writer<Secondary3,Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Writer<Secondary2,Array<Output>>>) -> State<Model,Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>> {
 		return flatMapT { (value) -> State<Model,Writer<Secondary2,Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Writer<Secondary2,Optional<Output>>>) -> State<Model,Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>> {
 		return flatMapT { (value) -> State<Model,Writer<Secondary2,Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Writer<Secondary2,Result<Secondary3,Output>>>) -> State<Model,Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> State<Model,Writer<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Writer<Secondary2,Result<Output,Secondary3>>>) -> State<Model,Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>> {
+		return flatMapT { (value) -> State<Model,Writer<Secondary2,Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> State<Model,Writer<Secondary2,Writer<Secondary3,Output>>>) -> State<Model,Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> State<Model,Writer<Secondary2,Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
@@ -916,148 +513,82 @@ public extension State {
 
 
 
-
 public extension Writer {
-
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Writer<Log,Array<Array<Output>>>) -> Writer<Log,Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
 		return flatMapT { (value) -> Writer<Log,Array<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Writer<Log,Array<Optional<Output>>>) -> Writer<Log,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
 		return flatMapT { (value) -> Writer<Log,Array<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Writer<Log,Array<Result<Secondary3,Output>>>) -> Writer<Log,Array<Result<Secondary3,Output>>> where ParameterType == Array<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Writer<Log,Array<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Writer<Log,Array<Result<Output,Secondary3>>>) -> Writer<Log,Array<Result<Output,Secondary3>>> where ParameterType == Array<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Writer<Log,Array<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Writer<Log,Array<Writer<Secondary3,Output>>>) -> Writer<Log,Array<Writer<Secondary3,Output>>> where ParameterType == Array<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Writer<Log,Array<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Writer<Log,Optional<Array<Output>>>) -> Writer<Log,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
 		return flatMapT { (value) -> Writer<Log,Optional<Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: (Input) -> Writer<Log,Optional<Optional<Output>>>) -> Writer<Log,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
 		return flatMapT { (value) -> Writer<Log,Optional<Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Writer<Log,Optional<Result<Secondary3,Output>>>) -> Writer<Log,Optional<Result<Secondary3,Output>>> where ParameterType == Optional<Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Writer<Log,Optional<Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Writer<Log,Optional<Result<Output,Secondary3>>>) -> Writer<Log,Optional<Result<Output,Secondary3>>> where ParameterType == Optional<Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Writer<Log,Optional<Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Input,Output> (_ transform: (Input) -> Writer<Log,Optional<Writer<Secondary3,Output>>>) -> Writer<Log,Optional<Writer<Secondary3,Output>>> where ParameterType == Optional<Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Writer<Log,Optional<Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Secondary2,Array<Output>>>) -> Writer<Log,Result<Secondary2,Array<Output>>> where ParameterType == Result<Secondary2,Array<Input>> {
-		return flatMapT { (value) -> Writer<Log,Result<Secondary2,Array<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Array<Output>,Secondary2>>) -> Writer<Log,Result<Array<Output>,Secondary2>> where ParameterType == Result<Array<Input>,Secondary2> {
+		return flatMapT { (value) -> Writer<Log,Result<Array<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Secondary2,Optional<Output>>>) -> Writer<Log,Result<Secondary2,Optional<Output>>> where ParameterType == Result<Secondary2,Optional<Input>> {
-		return flatMapT { (value) -> Writer<Log,Result<Secondary2,Optional<Output>>> in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Optional<Output>,Secondary2>>) -> Writer<Log,Result<Optional<Output>,Secondary2>> where ParameterType == Result<Optional<Input>,Secondary2> {
+		return flatMapT { (value) -> Writer<Log,Result<Optional<Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Secondary2,Result<Secondary3,Output>>>) -> Writer<Log,Result<Secondary2,Result<Secondary3,Output>>> where ParameterType == Result<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Writer<Log,Result<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Result<Output,Secondary3>,Secondary2>>) -> Writer<Log,Result<Result<Output,Secondary3>,Secondary2>> where ParameterType == Result<Result<Input,Secondary3>,Secondary2> {
+		return flatMapT { (value) -> Writer<Log,Result<Result<Output,Secondary3>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Secondary2,Writer<Secondary3,Output>>>) -> Writer<Log,Result<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Result<Secondary2,Writer<Secondary3,Input>> {
-		return flatMapT { (value) -> Writer<Log,Result<Secondary2,Writer<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Result<Writer<Secondary3,Output>,Secondary2>>) -> Writer<Log,Result<Writer<Secondary3,Output>,Secondary2>> where ParameterType == Result<Writer<Secondary3,Input>,Secondary2> {
+		return flatMapT { (value) -> Writer<Log,Result<Writer<Secondary3,Output>,Secondary2>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Writer<Secondary2,Array<Output>>>) -> Writer<Log,Writer<Secondary2,Array<Output>>> where ParameterType == Writer<Secondary2,Array<Input>> {
 		return flatMapT { (value) -> Writer<Log,Writer<Secondary2,Array<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.flatMap(f.identity) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Writer<Secondary2,Optional<Output>>>) -> Writer<Log,Writer<Secondary2,Optional<Output>>> where ParameterType == Writer<Secondary2,Optional<Input>> {
 		return flatMapT { (value) -> Writer<Log,Writer<Secondary2,Optional<Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Writer<Secondary2,Result<Secondary3,Output>>>) -> Writer<Log,Writer<Secondary2,Result<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Result<Secondary3,Input>> {
-		return flatMapT { (value) -> Writer<Log,Writer<Secondary2,Result<Secondary3,Output>>> in
+	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Writer<Secondary2,Result<Output,Secondary3>>>) -> Writer<Log,Writer<Secondary2,Result<Output,Secondary3>>> where ParameterType == Writer<Secondary2,Result<Input,Secondary3>> {
+		return flatMapT { (value) -> Writer<Log,Writer<Secondary2,Result<Output,Secondary3>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary3,Secondary2,Input,Output> (_ transform: (Input) -> Writer<Log,Writer<Secondary2,Writer<Secondary3,Output>>>) -> Writer<Log,Writer<Secondary2,Writer<Secondary3,Output>>> where ParameterType == Writer<Secondary2,Writer<Secondary3,Input>> {
 		return flatMapT { (value) -> Writer<Log,Writer<Secondary2,Writer<Secondary3,Output>>> in
 			value.traverse(transform).map { $0.traverse(f.identity) }.mapT { $0.joined() }
diff --git a/Sources/FunctionalKit/Optional.swift b/Sources/FunctionalKit/Optional.swift
index 0e5b5e9..c092235 100644
--- a/Sources/FunctionalKit/Optional.swift
+++ b/Sources/FunctionalKit/Optional.swift
@@ -167,7 +167,7 @@ public extension Optional{
         }
     }
 
-	func traverse <A,F> (_ transform: (ParameterType) -> Result<F,A>) -> Result<F,Optional<A>> {
+	func traverse <A,F> (_ transform: (ParameterType) -> Result<A,F>) -> Result<Optional<A>,F> {
 		switch self {
 		case let value?:
 			return Result.pure(Optional<A>.some) <*> transform(value)
@@ -222,7 +222,7 @@ public extension Optional{
         }
     }
     
-    func toResult <E> (getError: @autoclosure () -> E) -> Result<E,ParameterType> where E: Error {
+    func toResult <E> (getError: @autoclosure () -> E) -> Result<ParameterType,E> where E: Error {
 		switch self {
 		case let value?:
 			return .success(value)
diff --git a/Sources/FunctionalKit/Prism.swift b/Sources/FunctionalKit/Prism.swift
index ad31389..20c19fd 100644
--- a/Sources/FunctionalKit/Prism.swift
+++ b/Sources/FunctionalKit/Prism.swift
@@ -92,7 +92,7 @@ extension Result {
 			return iso.coproduct >>> Coproduct.prism.left
 		}
 
-		public static var success: Prism<Result,Parameter> {
+		public static var success: Prism<Result,Success> {
 			return iso.coproduct >>> Coproduct.prism.right
 		}
 	}
diff --git a/Sources/FunctionalKit/ReaderTransformer.generated.swift b/Sources/FunctionalKit/ReaderTransformer.generated.swift
index 666b0f0..131294c 100644
--- a/Sources/FunctionalKit/ReaderTransformer.generated.swift
+++ b/Sources/FunctionalKit/ReaderTransformer.generated.swift
@@ -3,1646 +3,885 @@
 
 
 
-
-
-
-
-
-
-
-
 public extension Reader {
-
-
-
     func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Output>>) -> Reader<Environment,Array<Output>> where ParameterType == Array<Input> {
         return Reader<Environment,Array<Output>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Output>>>) -> Reader<Environment,Array<Array<Output>>> where ParameterType == Array<Array<Input>> {
 		return Reader<Environment,Array<Array<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Array<Output>>>>) -> Reader<Environment,Array<Array<Array<Output>>>> where ParameterType == Array<Array<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Array<Output>>>>) -> Reader<Environment,Array<Array<Array<Output>>>> where ParameterType == Array<Array<Array<Input>>> {
 		return Reader<Environment,Array<Array<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Optional<Output>>>>) -> Reader<Environment,Array<Array<Optional<Output>>>> where ParameterType == Array<Array<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Optional<Output>>>>) -> Reader<Environment,Array<Array<Optional<Output>>>> where ParameterType == Array<Array<Optional<Input>>> {
 		return Reader<Environment,Array<Array<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Result<Secondary3,Output>>>>) -> Reader<Environment,Array<Array<Result<Secondary3,Output>>>> where ParameterType == Array<Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,Array<Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Result<Output,Secondary3>>>>) -> Reader<Environment,Array<Array<Result<Output,Secondary3>>>> where ParameterType == Array<Array<Result<Input,Secondary3>>> {
+		return Reader<Environment,Array<Array<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Array<Array<Writer<Secondary3,Output>>>> where ParameterType == Array<Array<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Array<Array<Writer<Secondary3,Output>>>> where ParameterType == Array<Array<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Array<Array<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Output>>>) -> Reader<Environment,Array<Optional<Output>>> where ParameterType == Array<Optional<Input>> {
 		return Reader<Environment,Array<Optional<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Array<Output>>>>) -> Reader<Environment,Array<Optional<Array<Output>>>> where ParameterType == Array<Optional<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Array<Output>>>>) -> Reader<Environment,Array<Optional<Array<Output>>>> where ParameterType == Array<Optional<Array<Input>>> {
 		return Reader<Environment,Array<Optional<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Optional<Output>>>>) -> Reader<Environment,Array<Optional<Optional<Output>>>> where ParameterType == Array<Optional<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Optional<Output>>>>) -> Reader<Environment,Array<Optional<Optional<Output>>>> where ParameterType == Array<Optional<Optional<Input>>> {
 		return Reader<Environment,Array<Optional<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,Array<Optional<Result<Secondary3,Output>>>> where ParameterType == Array<Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,Array<Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Result<Output,Secondary3>>>>) -> Reader<Environment,Array<Optional<Result<Output,Secondary3>>>> where ParameterType == Array<Optional<Result<Input,Secondary3>>> {
+		return Reader<Environment,Array<Optional<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Array<Optional<Writer<Secondary3,Output>>>> where ParameterType == Array<Optional<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Array<Optional<Writer<Secondary3,Output>>>> where ParameterType == Array<Optional<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Array<Optional<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Secondary2,Output>>>) -> Reader<Environment,Array<Result<Secondary2,Output>>> where ParameterType == Array<Result<Secondary2,Input>> {
-		return Reader<Environment,Array<Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Output,Secondary2>>>) -> Reader<Environment,Array<Result<Output,Secondary2>>> where ParameterType == Array<Result<Input,Secondary2>> {
+		return Reader<Environment,Array<Result<Output,Secondary2>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Secondary2,Array<Output>>>>) -> Reader<Environment,Array<Result<Secondary2,Array<Output>>>> where ParameterType == Array<Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,Array<Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Array<Output>,Secondary2>>>) -> Reader<Environment,Array<Result<Array<Output>,Secondary2>>> where ParameterType == Array<Result<Array<Input>,Secondary2>> {
+		return Reader<Environment,Array<Result<Array<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,Array<Result<Secondary2,Optional<Output>>>> where ParameterType == Array<Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Array<Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Optional<Output>,Secondary2>>>) -> Reader<Environment,Array<Result<Optional<Output>,Secondary2>>> where ParameterType == Array<Result<Optional<Input>,Secondary2>> {
+		return Reader<Environment,Array<Result<Optional<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Array<Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Array<Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Array<Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Result<Output,Secondary3>,Secondary2>>>) -> Reader<Environment,Array<Result<Result<Output,Secondary3>,Secondary2>>> where ParameterType == Array<Result<Result<Input,Secondary3>,Secondary2>> {
+		return Reader<Environment,Array<Result<Result<Output,Secondary3>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Array<Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Array<Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Array<Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Result<Writer<Secondary3,Output>,Secondary2>>>) -> Reader<Environment,Array<Result<Writer<Secondary3,Output>,Secondary2>>> where ParameterType == Array<Result<Writer<Secondary3,Input>,Secondary2>> {
+		return Reader<Environment,Array<Result<Writer<Secondary3,Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Output>>>) -> Reader<Environment,Array<Writer<Secondary2,Output>>> where ParameterType == Array<Writer<Secondary2,Input>> {
 		return Reader<Environment,Array<Writer<Secondary2,Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Array<Writer<Secondary2,Array<Output>>>> where ParameterType == Array<Writer<Secondary2,Array<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Array<Writer<Secondary2,Array<Output>>>> where ParameterType == Array<Writer<Secondary2,Array<Input>>> {
 		return Reader<Environment,Array<Writer<Secondary2,Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Array<Writer<Secondary2,Optional<Output>>>> where ParameterType == Array<Writer<Secondary2,Optional<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Array<Writer<Secondary2,Optional<Output>>>> where ParameterType == Array<Writer<Secondary2,Optional<Input>>> {
 		return Reader<Environment,Array<Writer<Secondary2,Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Array<Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Array<Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Array<Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Result<Output,Secondary3>>>>) -> Reader<Environment,Array<Writer<Secondary2,Result<Output,Secondary3>>>> where ParameterType == Array<Writer<Secondary2,Result<Input,Secondary3>>> {
+		return Reader<Environment,Array<Writer<Secondary2,Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Array<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Array<Writer<Secondary2,Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Array<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Array<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Array<Writer<Secondary2,Writer<Secondary3,Input>>> {
 		return Reader<Environment,Array<Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
     func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Output>>) -> Reader<Environment,Effect<Output>> where ParameterType == Effect<Input> {
         return Reader<Environment,Effect<Output>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Output>>>) -> Reader<Environment,Effect<Array<Output>>> where ParameterType == Effect<Array<Input>> {
 		return Reader<Environment,Effect<Array<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Array<Output>>>>) -> Reader<Environment,Effect<Array<Array<Output>>>> where ParameterType == Effect<Array<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Array<Output>>>>) -> Reader<Environment,Effect<Array<Array<Output>>>> where ParameterType == Effect<Array<Array<Input>>> {
 		return Reader<Environment,Effect<Array<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Optional<Output>>>>) -> Reader<Environment,Effect<Array<Optional<Output>>>> where ParameterType == Effect<Array<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Optional<Output>>>>) -> Reader<Environment,Effect<Array<Optional<Output>>>> where ParameterType == Effect<Array<Optional<Input>>> {
 		return Reader<Environment,Effect<Array<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Result<Secondary3,Output>>>>) -> Reader<Environment,Effect<Array<Result<Secondary3,Output>>>> where ParameterType == Effect<Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,Effect<Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Result<Output,Secondary3>>>>) -> Reader<Environment,Effect<Array<Result<Output,Secondary3>>>> where ParameterType == Effect<Array<Result<Input,Secondary3>>> {
+		return Reader<Environment,Effect<Array<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Effect<Array<Writer<Secondary3,Output>>>> where ParameterType == Effect<Array<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Effect<Array<Writer<Secondary3,Output>>>> where ParameterType == Effect<Array<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Effect<Array<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Output>>>) -> Reader<Environment,Effect<Optional<Output>>> where ParameterType == Effect<Optional<Input>> {
 		return Reader<Environment,Effect<Optional<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Array<Output>>>>) -> Reader<Environment,Effect<Optional<Array<Output>>>> where ParameterType == Effect<Optional<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Array<Output>>>>) -> Reader<Environment,Effect<Optional<Array<Output>>>> where ParameterType == Effect<Optional<Array<Input>>> {
 		return Reader<Environment,Effect<Optional<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Optional<Output>>>>) -> Reader<Environment,Effect<Optional<Optional<Output>>>> where ParameterType == Effect<Optional<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Optional<Output>>>>) -> Reader<Environment,Effect<Optional<Optional<Output>>>> where ParameterType == Effect<Optional<Optional<Input>>> {
 		return Reader<Environment,Effect<Optional<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,Effect<Optional<Result<Secondary3,Output>>>> where ParameterType == Effect<Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,Effect<Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Result<Output,Secondary3>>>>) -> Reader<Environment,Effect<Optional<Result<Output,Secondary3>>>> where ParameterType == Effect<Optional<Result<Input,Secondary3>>> {
+		return Reader<Environment,Effect<Optional<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Effect<Optional<Writer<Secondary3,Output>>>> where ParameterType == Effect<Optional<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Effect<Optional<Writer<Secondary3,Output>>>> where ParameterType == Effect<Optional<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Effect<Optional<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Secondary2,Output>>>) -> Reader<Environment,Effect<Result<Secondary2,Output>>> where ParameterType == Effect<Result<Secondary2,Input>> {
-		return Reader<Environment,Effect<Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Output,Secondary2>>>) -> Reader<Environment,Effect<Result<Output,Secondary2>>> where ParameterType == Effect<Result<Input,Secondary2>> {
+		return Reader<Environment,Effect<Result<Output,Secondary2>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Secondary2,Array<Output>>>>) -> Reader<Environment,Effect<Result<Secondary2,Array<Output>>>> where ParameterType == Effect<Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,Effect<Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Array<Output>,Secondary2>>>) -> Reader<Environment,Effect<Result<Array<Output>,Secondary2>>> where ParameterType == Effect<Result<Array<Input>,Secondary2>> {
+		return Reader<Environment,Effect<Result<Array<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,Effect<Result<Secondary2,Optional<Output>>>> where ParameterType == Effect<Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Effect<Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Optional<Output>,Secondary2>>>) -> Reader<Environment,Effect<Result<Optional<Output>,Secondary2>>> where ParameterType == Effect<Result<Optional<Input>,Secondary2>> {
+		return Reader<Environment,Effect<Result<Optional<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Effect<Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Effect<Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Effect<Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Result<Output,Secondary3>,Secondary2>>>) -> Reader<Environment,Effect<Result<Result<Output,Secondary3>,Secondary2>>> where ParameterType == Effect<Result<Result<Input,Secondary3>,Secondary2>> {
+		return Reader<Environment,Effect<Result<Result<Output,Secondary3>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Effect<Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Effect<Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Effect<Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Result<Writer<Secondary3,Output>,Secondary2>>>) -> Reader<Environment,Effect<Result<Writer<Secondary3,Output>,Secondary2>>> where ParameterType == Effect<Result<Writer<Secondary3,Input>,Secondary2>> {
+		return Reader<Environment,Effect<Result<Writer<Secondary3,Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Output>>>) -> Reader<Environment,Effect<Writer<Secondary2,Output>>> where ParameterType == Effect<Writer<Secondary2,Input>> {
 		return Reader<Environment,Effect<Writer<Secondary2,Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Array<Output>>>> where ParameterType == Effect<Writer<Secondary2,Array<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Array<Output>>>> where ParameterType == Effect<Writer<Secondary2,Array<Input>>> {
 		return Reader<Environment,Effect<Writer<Secondary2,Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Optional<Output>>>> where ParameterType == Effect<Writer<Secondary2,Optional<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Optional<Output>>>> where ParameterType == Effect<Writer<Secondary2,Optional<Input>>> {
 		return Reader<Environment,Effect<Writer<Secondary2,Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Effect<Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Effect<Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Result<Output,Secondary3>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Result<Output,Secondary3>>>> where ParameterType == Effect<Writer<Secondary2,Result<Input,Secondary3>>> {
+		return Reader<Environment,Effect<Writer<Secondary2,Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Effect<Writer<Secondary2,Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Effect<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Effect<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Effect<Writer<Secondary2,Writer<Secondary3,Input>>> {
 		return Reader<Environment,Effect<Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
     func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Output>>) -> Reader<Environment,Future<Output>> where ParameterType == Future<Input> {
         return Reader<Environment,Future<Output>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Output>>>) -> Reader<Environment,Future<Array<Output>>> where ParameterType == Future<Array<Input>> {
 		return Reader<Environment,Future<Array<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Array<Output>>>>) -> Reader<Environment,Future<Array<Array<Output>>>> where ParameterType == Future<Array<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Array<Output>>>>) -> Reader<Environment,Future<Array<Array<Output>>>> where ParameterType == Future<Array<Array<Input>>> {
 		return Reader<Environment,Future<Array<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Optional<Output>>>>) -> Reader<Environment,Future<Array<Optional<Output>>>> where ParameterType == Future<Array<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Optional<Output>>>>) -> Reader<Environment,Future<Array<Optional<Output>>>> where ParameterType == Future<Array<Optional<Input>>> {
 		return Reader<Environment,Future<Array<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Result<Secondary3,Output>>>>) -> Reader<Environment,Future<Array<Result<Secondary3,Output>>>> where ParameterType == Future<Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,Future<Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Result<Output,Secondary3>>>>) -> Reader<Environment,Future<Array<Result<Output,Secondary3>>>> where ParameterType == Future<Array<Result<Input,Secondary3>>> {
+		return Reader<Environment,Future<Array<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Future<Array<Writer<Secondary3,Output>>>> where ParameterType == Future<Array<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Future<Array<Writer<Secondary3,Output>>>> where ParameterType == Future<Array<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Future<Array<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Output>>>) -> Reader<Environment,Future<Optional<Output>>> where ParameterType == Future<Optional<Input>> {
 		return Reader<Environment,Future<Optional<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Array<Output>>>>) -> Reader<Environment,Future<Optional<Array<Output>>>> where ParameterType == Future<Optional<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Array<Output>>>>) -> Reader<Environment,Future<Optional<Array<Output>>>> where ParameterType == Future<Optional<Array<Input>>> {
 		return Reader<Environment,Future<Optional<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Optional<Output>>>>) -> Reader<Environment,Future<Optional<Optional<Output>>>> where ParameterType == Future<Optional<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Optional<Output>>>>) -> Reader<Environment,Future<Optional<Optional<Output>>>> where ParameterType == Future<Optional<Optional<Input>>> {
 		return Reader<Environment,Future<Optional<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,Future<Optional<Result<Secondary3,Output>>>> where ParameterType == Future<Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,Future<Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Result<Output,Secondary3>>>>) -> Reader<Environment,Future<Optional<Result<Output,Secondary3>>>> where ParameterType == Future<Optional<Result<Input,Secondary3>>> {
+		return Reader<Environment,Future<Optional<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Future<Optional<Writer<Secondary3,Output>>>> where ParameterType == Future<Optional<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Future<Optional<Writer<Secondary3,Output>>>> where ParameterType == Future<Optional<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Future<Optional<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Secondary2,Output>>>) -> Reader<Environment,Future<Result<Secondary2,Output>>> where ParameterType == Future<Result<Secondary2,Input>> {
-		return Reader<Environment,Future<Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Output,Secondary2>>>) -> Reader<Environment,Future<Result<Output,Secondary2>>> where ParameterType == Future<Result<Input,Secondary2>> {
+		return Reader<Environment,Future<Result<Output,Secondary2>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Secondary2,Array<Output>>>>) -> Reader<Environment,Future<Result<Secondary2,Array<Output>>>> where ParameterType == Future<Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,Future<Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Array<Output>,Secondary2>>>) -> Reader<Environment,Future<Result<Array<Output>,Secondary2>>> where ParameterType == Future<Result<Array<Input>,Secondary2>> {
+		return Reader<Environment,Future<Result<Array<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,Future<Result<Secondary2,Optional<Output>>>> where ParameterType == Future<Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Future<Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Optional<Output>,Secondary2>>>) -> Reader<Environment,Future<Result<Optional<Output>,Secondary2>>> where ParameterType == Future<Result<Optional<Input>,Secondary2>> {
+		return Reader<Environment,Future<Result<Optional<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Future<Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Future<Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Future<Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Result<Output,Secondary3>,Secondary2>>>) -> Reader<Environment,Future<Result<Result<Output,Secondary3>,Secondary2>>> where ParameterType == Future<Result<Result<Input,Secondary3>,Secondary2>> {
+		return Reader<Environment,Future<Result<Result<Output,Secondary3>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Future<Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Future<Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Future<Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Result<Writer<Secondary3,Output>,Secondary2>>>) -> Reader<Environment,Future<Result<Writer<Secondary3,Output>,Secondary2>>> where ParameterType == Future<Result<Writer<Secondary3,Input>,Secondary2>> {
+		return Reader<Environment,Future<Result<Writer<Secondary3,Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Output>>>) -> Reader<Environment,Future<Writer<Secondary2,Output>>> where ParameterType == Future<Writer<Secondary2,Input>> {
 		return Reader<Environment,Future<Writer<Secondary2,Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Future<Writer<Secondary2,Array<Output>>>> where ParameterType == Future<Writer<Secondary2,Array<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Future<Writer<Secondary2,Array<Output>>>> where ParameterType == Future<Writer<Secondary2,Array<Input>>> {
 		return Reader<Environment,Future<Writer<Secondary2,Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Future<Writer<Secondary2,Optional<Output>>>> where ParameterType == Future<Writer<Secondary2,Optional<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Future<Writer<Secondary2,Optional<Output>>>> where ParameterType == Future<Writer<Secondary2,Optional<Input>>> {
 		return Reader<Environment,Future<Writer<Secondary2,Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Future<Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Future<Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Future<Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Result<Output,Secondary3>>>>) -> Reader<Environment,Future<Writer<Secondary2,Result<Output,Secondary3>>>> where ParameterType == Future<Writer<Secondary2,Result<Input,Secondary3>>> {
+		return Reader<Environment,Future<Writer<Secondary2,Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Future<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Future<Writer<Secondary2,Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Future<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Future<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Future<Writer<Secondary2,Writer<Secondary3,Input>>> {
 		return Reader<Environment,Future<Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
     func flatMapT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Output>>) -> Reader<Environment,Optional<Output>> where ParameterType == Optional<Input> {
         return Reader<Environment,Optional<Output>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Output>>>) -> Reader<Environment,Optional<Array<Output>>> where ParameterType == Optional<Array<Input>> {
 		return Reader<Environment,Optional<Array<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Array<Output>>>>) -> Reader<Environment,Optional<Array<Array<Output>>>> where ParameterType == Optional<Array<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Array<Output>>>>) -> Reader<Environment,Optional<Array<Array<Output>>>> where ParameterType == Optional<Array<Array<Input>>> {
 		return Reader<Environment,Optional<Array<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Optional<Output>>>>) -> Reader<Environment,Optional<Array<Optional<Output>>>> where ParameterType == Optional<Array<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Optional<Output>>>>) -> Reader<Environment,Optional<Array<Optional<Output>>>> where ParameterType == Optional<Array<Optional<Input>>> {
 		return Reader<Environment,Optional<Array<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Result<Secondary3,Output>>>>) -> Reader<Environment,Optional<Array<Result<Secondary3,Output>>>> where ParameterType == Optional<Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,Optional<Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Result<Output,Secondary3>>>>) -> Reader<Environment,Optional<Array<Result<Output,Secondary3>>>> where ParameterType == Optional<Array<Result<Input,Secondary3>>> {
+		return Reader<Environment,Optional<Array<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Optional<Array<Writer<Secondary3,Output>>>> where ParameterType == Optional<Array<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Optional<Array<Writer<Secondary3,Output>>>> where ParameterType == Optional<Array<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Optional<Array<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Output>>>) -> Reader<Environment,Optional<Optional<Output>>> where ParameterType == Optional<Optional<Input>> {
 		return Reader<Environment,Optional<Optional<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Array<Output>>>>) -> Reader<Environment,Optional<Optional<Array<Output>>>> where ParameterType == Optional<Optional<Array<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Array<Output>>>>) -> Reader<Environment,Optional<Optional<Array<Output>>>> where ParameterType == Optional<Optional<Array<Input>>> {
 		return Reader<Environment,Optional<Optional<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Optional<Output>>>>) -> Reader<Environment,Optional<Optional<Optional<Output>>>> where ParameterType == Optional<Optional<Optional<Input>>> {
+	func flatMapTTT<Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Optional<Output>>>>) -> Reader<Environment,Optional<Optional<Optional<Output>>>> where ParameterType == Optional<Optional<Optional<Input>>> {
 		return Reader<Environment,Optional<Optional<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,Optional<Optional<Result<Secondary3,Output>>>> where ParameterType == Optional<Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,Optional<Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Result<Output,Secondary3>>>>) -> Reader<Environment,Optional<Optional<Result<Output,Secondary3>>>> where ParameterType == Optional<Optional<Result<Input,Secondary3>>> {
+		return Reader<Environment,Optional<Optional<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Optional<Optional<Writer<Secondary3,Output>>>> where ParameterType == Optional<Optional<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Optional<Optional<Writer<Secondary3,Output>>>> where ParameterType == Optional<Optional<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Optional<Optional<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Secondary2,Output>>>) -> Reader<Environment,Optional<Result<Secondary2,Output>>> where ParameterType == Optional<Result<Secondary2,Input>> {
-		return Reader<Environment,Optional<Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Output,Secondary2>>>) -> Reader<Environment,Optional<Result<Output,Secondary2>>> where ParameterType == Optional<Result<Input,Secondary2>> {
+		return Reader<Environment,Optional<Result<Output,Secondary2>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Secondary2,Array<Output>>>>) -> Reader<Environment,Optional<Result<Secondary2,Array<Output>>>> where ParameterType == Optional<Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,Optional<Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Array<Output>,Secondary2>>>) -> Reader<Environment,Optional<Result<Array<Output>,Secondary2>>> where ParameterType == Optional<Result<Array<Input>,Secondary2>> {
+		return Reader<Environment,Optional<Result<Array<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,Optional<Result<Secondary2,Optional<Output>>>> where ParameterType == Optional<Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Optional<Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Optional<Output>,Secondary2>>>) -> Reader<Environment,Optional<Result<Optional<Output>,Secondary2>>> where ParameterType == Optional<Result<Optional<Input>,Secondary2>> {
+		return Reader<Environment,Optional<Result<Optional<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Optional<Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Optional<Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Optional<Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Result<Output,Secondary3>,Secondary2>>>) -> Reader<Environment,Optional<Result<Result<Output,Secondary3>,Secondary2>>> where ParameterType == Optional<Result<Result<Input,Secondary3>,Secondary2>> {
+		return Reader<Environment,Optional<Result<Result<Output,Secondary3>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Optional<Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Optional<Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Optional<Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Result<Writer<Secondary3,Output>,Secondary2>>>) -> Reader<Environment,Optional<Result<Writer<Secondary3,Output>,Secondary2>>> where ParameterType == Optional<Result<Writer<Secondary3,Input>,Secondary2>> {
+		return Reader<Environment,Optional<Result<Writer<Secondary3,Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Output>>>) -> Reader<Environment,Optional<Writer<Secondary2,Output>>> where ParameterType == Optional<Writer<Secondary2,Input>> {
 		return Reader<Environment,Optional<Writer<Secondary2,Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Array<Output>>>> where ParameterType == Optional<Writer<Secondary2,Array<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Array<Output>>>> where ParameterType == Optional<Writer<Secondary2,Array<Input>>> {
 		return Reader<Environment,Optional<Writer<Secondary2,Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Optional<Output>>>> where ParameterType == Optional<Writer<Secondary2,Optional<Input>>> {
+	func flatMapTTT<Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Optional<Output>>>> where ParameterType == Optional<Writer<Secondary2,Optional<Input>>> {
 		return Reader<Environment,Optional<Writer<Secondary2,Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Optional<Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Optional<Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Result<Output,Secondary3>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Result<Output,Secondary3>>>> where ParameterType == Optional<Writer<Secondary2,Result<Input,Secondary3>>> {
+		return Reader<Environment,Optional<Writer<Secondary2,Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Optional<Writer<Secondary2,Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary2,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Optional<Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Optional<Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Optional<Writer<Secondary2,Writer<Secondary3,Input>>> {
 		return Reader<Environment,Optional<Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-    func flatMapT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Output>>) -> Reader<Environment,Reader<Secondary1,Output>> where ParameterType == Reader<Secondary1,Input> {
-        return Reader<Environment,Reader<Secondary1,Output>>.init { e in
+    func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary,Output>>) -> Reader<Environment,Reader<Secondary,Output>> where ParameterType == Reader<Secondary,Input> {
+        return Reader<Environment,Reader<Secondary,Output>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
 	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Output>>>) -> Reader<Environment,Reader<Secondary1,Array<Output>>> where ParameterType == Reader<Secondary1,Array<Input>> {
 		return Reader<Environment,Reader<Secondary1,Array<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Array<Output>>>>) -> Reader<Environment,Reader<Secondary1,Array<Array<Output>>>> where ParameterType == Reader<Secondary1,Array<Array<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Array<Output>>>>) -> Reader<Environment,Reader<Secondary1,Array<Array<Output>>>> where ParameterType == Reader<Secondary1,Array<Array<Input>>> {
 		return Reader<Environment,Reader<Secondary1,Array<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Optional<Output>>>>) -> Reader<Environment,Reader<Secondary1,Array<Optional<Output>>>> where ParameterType == Reader<Secondary1,Array<Optional<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Optional<Output>>>>) -> Reader<Environment,Reader<Secondary1,Array<Optional<Output>>>> where ParameterType == Reader<Secondary1,Array<Optional<Input>>> {
 		return Reader<Environment,Reader<Secondary1,Array<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Result<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Array<Result<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,Reader<Secondary1,Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Result<Output,Secondary3>>>>) -> Reader<Environment,Reader<Secondary1,Array<Result<Output,Secondary3>>>> where ParameterType == Reader<Secondary1,Array<Result<Input,Secondary3>>> {
+		return Reader<Environment,Reader<Secondary1,Array<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Array<Writer<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Array<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Array<Writer<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Array<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Reader<Secondary1,Array<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Output>>>) -> Reader<Environment,Reader<Secondary1,Optional<Output>>> where ParameterType == Reader<Secondary1,Optional<Input>> {
 		return Reader<Environment,Reader<Secondary1,Optional<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Array<Output>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Array<Output>>>> where ParameterType == Reader<Secondary1,Optional<Array<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Array<Output>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Array<Output>>>> where ParameterType == Reader<Secondary1,Optional<Array<Input>>> {
 		return Reader<Environment,Reader<Secondary1,Optional<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Optional<Output>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Optional<Output>>>> where ParameterType == Reader<Secondary1,Optional<Optional<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Optional<Output>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Optional<Output>>>> where ParameterType == Reader<Secondary1,Optional<Optional<Input>>> {
 		return Reader<Environment,Reader<Secondary1,Optional<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Result<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,Reader<Secondary1,Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Result<Output,Secondary3>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Result<Output,Secondary3>>>> where ParameterType == Reader<Secondary1,Optional<Result<Input,Secondary3>>> {
+		return Reader<Environment,Reader<Secondary1,Optional<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Writer<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Optional<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Optional<Writer<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Optional<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Reader<Secondary1,Optional<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Output>>>) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Output>>> where ParameterType == Reader<Secondary1,Result<Secondary2,Input>> {
-		return Reader<Environment,Reader<Secondary1,Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Output,Secondary2>>>) -> Reader<Environment,Reader<Secondary1,Result<Output,Secondary2>>> where ParameterType == Reader<Secondary1,Result<Input,Secondary2>> {
+		return Reader<Environment,Reader<Secondary1,Result<Output,Secondary2>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Array<Output>>>>) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Array<Output>>>> where ParameterType == Reader<Secondary1,Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,Reader<Secondary1,Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Array<Output>,Secondary2>>>) -> Reader<Environment,Reader<Secondary1,Result<Array<Output>,Secondary2>>> where ParameterType == Reader<Secondary1,Result<Array<Input>,Secondary2>> {
+		return Reader<Environment,Reader<Secondary1,Result<Array<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Optional<Output>>>> where ParameterType == Reader<Secondary1,Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Reader<Secondary1,Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Optional<Output>,Secondary2>>>) -> Reader<Environment,Reader<Secondary1,Result<Optional<Output>,Secondary2>>> where ParameterType == Reader<Secondary1,Result<Optional<Input>,Secondary2>> {
+		return Reader<Environment,Reader<Secondary1,Result<Optional<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Reader<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>>) -> Reader<Environment,Reader<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>> where ParameterType == Reader<Secondary1,Result<Result<Input,Secondary3>,Secondary2>> {
+		return Reader<Environment,Reader<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Reader<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>>) -> Reader<Environment,Reader<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>> where ParameterType == Reader<Secondary1,Result<Writer<Secondary3,Input>,Secondary2>> {
+		return Reader<Environment,Reader<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Output>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Output>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Input>> {
 		return Reader<Environment,Reader<Secondary1,Writer<Secondary2,Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Array<Output>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Array<Input>>> {
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Array<Output>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Array<Input>>> {
 		return Reader<Environment,Reader<Secondary1,Writer<Secondary2,Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Optional<Output>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Optional<Input>>> {
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Optional<Output>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Optional<Input>>> {
 		return Reader<Environment,Reader<Secondary1,Writer<Secondary2,Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Reader<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Result<Input,Secondary3>>> {
+		return Reader<Environment,Reader<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Reader<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Reader<Secondary1,Writer<Secondary2,Writer<Secondary3,Input>>> {
 		return Reader<Environment,Reader<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-    func flatMapT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Output>>) -> Reader<Environment,Result<Secondary1,Output>> where ParameterType == Result<Secondary1,Input> {
-        return Reader<Environment,Result<Secondary1,Output>>.init { e in
+    func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Output,Secondary>>) -> Reader<Environment,Result<Output,Secondary>> where ParameterType == Result<Input,Secondary> {
+        return Reader<Environment,Result<Output,Secondary>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
-	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Array<Output>>>) -> Reader<Environment,Result<Secondary1,Array<Output>>> where ParameterType == Result<Secondary1,Array<Input>> {
-		return Reader<Environment,Result<Secondary1,Array<Output>>>.init { e in
+	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Array<Output>,Secondary1>>) -> Reader<Environment,Result<Array<Output>,Secondary1>> where ParameterType == Result<Array<Input>,Secondary1> {
+		return Reader<Environment,Result<Array<Output>,Secondary1>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Array<Array<Output>>>>) -> Reader<Environment,Result<Secondary1,Array<Array<Output>>>> where ParameterType == Result<Secondary1,Array<Array<Input>>> {
-		return Reader<Environment,Result<Secondary1,Array<Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Array<Array<Output>>,Secondary1>>) -> Reader<Environment,Result<Array<Array<Output>>,Secondary1>> where ParameterType == Result<Array<Array<Input>>,Secondary1> {
+		return Reader<Environment,Result<Array<Array<Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Array<Optional<Output>>>>) -> Reader<Environment,Result<Secondary1,Array<Optional<Output>>>> where ParameterType == Result<Secondary1,Array<Optional<Input>>> {
-		return Reader<Environment,Result<Secondary1,Array<Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Array<Optional<Output>>,Secondary1>>) -> Reader<Environment,Result<Array<Optional<Output>>,Secondary1>> where ParameterType == Result<Array<Optional<Input>>,Secondary1> {
+		return Reader<Environment,Result<Array<Optional<Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Array<Result<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Array<Result<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Array<Result<Output,Secondary3>>,Secondary1>>) -> Reader<Environment,Result<Array<Result<Output,Secondary3>>,Secondary1>> where ParameterType == Result<Array<Result<Input,Secondary3>>,Secondary1> {
+		return Reader<Environment,Result<Array<Result<Output,Secondary3>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Array<Writer<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Array<Writer<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Array<Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Array<Writer<Secondary3,Output>>,Secondary1>>) -> Reader<Environment,Result<Array<Writer<Secondary3,Output>>,Secondary1>> where ParameterType == Result<Array<Writer<Secondary3,Input>>,Secondary1> {
+		return Reader<Environment,Result<Array<Writer<Secondary3,Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Optional<Output>>>) -> Reader<Environment,Result<Secondary1,Optional<Output>>> where ParameterType == Result<Secondary1,Optional<Input>> {
-		return Reader<Environment,Result<Secondary1,Optional<Output>>>.init { e in
+	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Optional<Output>,Secondary1>>) -> Reader<Environment,Result<Optional<Output>,Secondary1>> where ParameterType == Result<Optional<Input>,Secondary1> {
+		return Reader<Environment,Result<Optional<Output>,Secondary1>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Optional<Array<Output>>>>) -> Reader<Environment,Result<Secondary1,Optional<Array<Output>>>> where ParameterType == Result<Secondary1,Optional<Array<Input>>> {
-		return Reader<Environment,Result<Secondary1,Optional<Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Optional<Array<Output>>,Secondary1>>) -> Reader<Environment,Result<Optional<Array<Output>>,Secondary1>> where ParameterType == Result<Optional<Array<Input>>,Secondary1> {
+		return Reader<Environment,Result<Optional<Array<Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Optional<Optional<Output>>>>) -> Reader<Environment,Result<Secondary1,Optional<Optional<Output>>>> where ParameterType == Result<Secondary1,Optional<Optional<Input>>> {
-		return Reader<Environment,Result<Secondary1,Optional<Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Optional<Optional<Output>>,Secondary1>>) -> Reader<Environment,Result<Optional<Optional<Output>>,Secondary1>> where ParameterType == Result<Optional<Optional<Input>>,Secondary1> {
+		return Reader<Environment,Result<Optional<Optional<Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Optional<Result<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Optional<Result<Output,Secondary3>>,Secondary1>>) -> Reader<Environment,Result<Optional<Result<Output,Secondary3>>,Secondary1>> where ParameterType == Result<Optional<Result<Input,Secondary3>>,Secondary1> {
+		return Reader<Environment,Result<Optional<Result<Output,Secondary3>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Optional<Writer<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Optional<Writer<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Optional<Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Optional<Writer<Secondary3,Output>>,Secondary1>>) -> Reader<Environment,Result<Optional<Writer<Secondary3,Output>>,Secondary1>> where ParameterType == Result<Optional<Writer<Secondary3,Input>>,Secondary1> {
+		return Reader<Environment,Result<Optional<Writer<Secondary3,Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Output>>>) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Output>>> where ParameterType == Result<Secondary1,Result<Secondary2,Input>> {
-		return Reader<Environment,Result<Secondary1,Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Result<Output,Secondary2>,Secondary1>>) -> Reader<Environment,Result<Result<Output,Secondary2>,Secondary1>> where ParameterType == Result<Result<Input,Secondary2>,Secondary1> {
+		return Reader<Environment,Result<Result<Output,Secondary2>,Secondary1>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Array<Output>>>>) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Array<Output>>>> where ParameterType == Result<Secondary1,Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,Result<Secondary1,Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Result<Array<Output>,Secondary2>,Secondary1>>) -> Reader<Environment,Result<Result<Array<Output>,Secondary2>,Secondary1>> where ParameterType == Result<Result<Array<Input>,Secondary2>,Secondary1> {
+		return Reader<Environment,Result<Result<Array<Output>,Secondary2>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Optional<Output>>>> where ParameterType == Result<Secondary1,Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Result<Secondary1,Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Result<Optional<Output>,Secondary2>,Secondary1>>) -> Reader<Environment,Result<Result<Optional<Output>,Secondary2>,Secondary1>> where ParameterType == Result<Result<Optional<Input>,Secondary2>,Secondary1> {
+		return Reader<Environment,Result<Result<Optional<Output>,Secondary2>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Result<Result<Output,Secondary3>,Secondary2>,Secondary1>>) -> Reader<Environment,Result<Result<Result<Output,Secondary3>,Secondary2>,Secondary1>> where ParameterType == Result<Result<Result<Input,Secondary3>,Secondary2>,Secondary1> {
+		return Reader<Environment,Result<Result<Result<Output,Secondary3>,Secondary2>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Result<Writer<Secondary3,Output>,Secondary2>,Secondary1>>) -> Reader<Environment,Result<Result<Writer<Secondary3,Output>,Secondary2>,Secondary1>> where ParameterType == Result<Result<Writer<Secondary3,Input>,Secondary2>,Secondary1> {
+		return Reader<Environment,Result<Result<Writer<Secondary3,Output>,Secondary2>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Output>>>) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Output>>> where ParameterType == Result<Secondary1,Writer<Secondary2,Input>> {
-		return Reader<Environment,Result<Secondary1,Writer<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Writer<Secondary2,Output>,Secondary1>>) -> Reader<Environment,Result<Writer<Secondary2,Output>,Secondary1>> where ParameterType == Result<Writer<Secondary2,Input>,Secondary1> {
+		return Reader<Environment,Result<Writer<Secondary2,Output>,Secondary1>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Array<Output>>>> where ParameterType == Result<Secondary1,Writer<Secondary2,Array<Input>>> {
-		return Reader<Environment,Result<Secondary1,Writer<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Writer<Secondary2,Array<Output>>,Secondary1>>) -> Reader<Environment,Result<Writer<Secondary2,Array<Output>>,Secondary1>> where ParameterType == Result<Writer<Secondary2,Array<Input>>,Secondary1> {
+		return Reader<Environment,Result<Writer<Secondary2,Array<Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Optional<Output>>>> where ParameterType == Result<Secondary1,Writer<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Result<Secondary1,Writer<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Writer<Secondary2,Optional<Output>>,Secondary1>>) -> Reader<Environment,Result<Writer<Secondary2,Optional<Output>>,Secondary1>> where ParameterType == Result<Writer<Secondary2,Optional<Input>>,Secondary1> {
+		return Reader<Environment,Result<Writer<Secondary2,Optional<Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Writer<Secondary2,Result<Output,Secondary3>>,Secondary1>>) -> Reader<Environment,Result<Writer<Secondary2,Result<Output,Secondary3>>,Secondary1>> where ParameterType == Result<Writer<Secondary2,Result<Input,Secondary3>>,Secondary1> {
+		return Reader<Environment,Result<Writer<Secondary2,Result<Output,Secondary3>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Result<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Result<Secondary1,Writer<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Result<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Result<Writer<Secondary2,Writer<Secondary3,Output>>,Secondary1>>) -> Reader<Environment,Result<Writer<Secondary2,Writer<Secondary3,Output>>,Secondary1>> where ParameterType == Result<Writer<Secondary2,Writer<Secondary3,Input>>,Secondary1> {
+		return Reader<Environment,Result<Writer<Secondary2,Writer<Secondary3,Output>>,Secondary1>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-    func flatMapT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Output>>) -> Reader<Environment,State<Secondary1,Output>> where ParameterType == State<Secondary1,Input> {
-        return Reader<Environment,State<Secondary1,Output>>.init { e in
+    func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary,Output>>) -> Reader<Environment,State<Secondary,Output>> where ParameterType == State<Secondary,Input> {
+        return Reader<Environment,State<Secondary,Output>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
 	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Output>>>) -> Reader<Environment,State<Secondary1,Array<Output>>> where ParameterType == State<Secondary1,Array<Input>> {
 		return Reader<Environment,State<Secondary1,Array<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Array<Output>>>>) -> Reader<Environment,State<Secondary1,Array<Array<Output>>>> where ParameterType == State<Secondary1,Array<Array<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Array<Output>>>>) -> Reader<Environment,State<Secondary1,Array<Array<Output>>>> where ParameterType == State<Secondary1,Array<Array<Input>>> {
 		return Reader<Environment,State<Secondary1,Array<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Optional<Output>>>>) -> Reader<Environment,State<Secondary1,Array<Optional<Output>>>> where ParameterType == State<Secondary1,Array<Optional<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Optional<Output>>>>) -> Reader<Environment,State<Secondary1,Array<Optional<Output>>>> where ParameterType == State<Secondary1,Array<Optional<Input>>> {
 		return Reader<Environment,State<Secondary1,Array<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Result<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Array<Result<Secondary3,Output>>>> where ParameterType == State<Secondary1,Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,State<Secondary1,Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Result<Output,Secondary3>>>>) -> Reader<Environment,State<Secondary1,Array<Result<Output,Secondary3>>>> where ParameterType == State<Secondary1,Array<Result<Input,Secondary3>>> {
+		return Reader<Environment,State<Secondary1,Array<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Array<Writer<Secondary3,Output>>>> where ParameterType == State<Secondary1,Array<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Array<Writer<Secondary3,Output>>>> where ParameterType == State<Secondary1,Array<Writer<Secondary3,Input>>> {
 		return Reader<Environment,State<Secondary1,Array<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Output>>>) -> Reader<Environment,State<Secondary1,Optional<Output>>> where ParameterType == State<Secondary1,Optional<Input>> {
 		return Reader<Environment,State<Secondary1,Optional<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Array<Output>>>>) -> Reader<Environment,State<Secondary1,Optional<Array<Output>>>> where ParameterType == State<Secondary1,Optional<Array<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Array<Output>>>>) -> Reader<Environment,State<Secondary1,Optional<Array<Output>>>> where ParameterType == State<Secondary1,Optional<Array<Input>>> {
 		return Reader<Environment,State<Secondary1,Optional<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Optional<Output>>>>) -> Reader<Environment,State<Secondary1,Optional<Optional<Output>>>> where ParameterType == State<Secondary1,Optional<Optional<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Optional<Output>>>>) -> Reader<Environment,State<Secondary1,Optional<Optional<Output>>>> where ParameterType == State<Secondary1,Optional<Optional<Input>>> {
 		return Reader<Environment,State<Secondary1,Optional<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Optional<Result<Secondary3,Output>>>> where ParameterType == State<Secondary1,Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,State<Secondary1,Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Result<Output,Secondary3>>>>) -> Reader<Environment,State<Secondary1,Optional<Result<Output,Secondary3>>>> where ParameterType == State<Secondary1,Optional<Result<Input,Secondary3>>> {
+		return Reader<Environment,State<Secondary1,Optional<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Optional<Writer<Secondary3,Output>>>> where ParameterType == State<Secondary1,Optional<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Optional<Writer<Secondary3,Output>>>> where ParameterType == State<Secondary1,Optional<Writer<Secondary3,Input>>> {
 		return Reader<Environment,State<Secondary1,Optional<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Secondary2,Output>>>) -> Reader<Environment,State<Secondary1,Result<Secondary2,Output>>> where ParameterType == State<Secondary1,Result<Secondary2,Input>> {
-		return Reader<Environment,State<Secondary1,Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Output,Secondary2>>>) -> Reader<Environment,State<Secondary1,Result<Output,Secondary2>>> where ParameterType == State<Secondary1,Result<Input,Secondary2>> {
+		return Reader<Environment,State<Secondary1,Result<Output,Secondary2>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Secondary2,Array<Output>>>>) -> Reader<Environment,State<Secondary1,Result<Secondary2,Array<Output>>>> where ParameterType == State<Secondary1,Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,State<Secondary1,Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Array<Output>,Secondary2>>>) -> Reader<Environment,State<Secondary1,Result<Array<Output>,Secondary2>>> where ParameterType == State<Secondary1,Result<Array<Input>,Secondary2>> {
+		return Reader<Environment,State<Secondary1,Result<Array<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,State<Secondary1,Result<Secondary2,Optional<Output>>>> where ParameterType == State<Secondary1,Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,State<Secondary1,Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Optional<Output>,Secondary2>>>) -> Reader<Environment,State<Secondary1,Result<Optional<Output>,Secondary2>>> where ParameterType == State<Secondary1,Result<Optional<Input>,Secondary2>> {
+		return Reader<Environment,State<Secondary1,Result<Optional<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == State<Secondary1,Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,State<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>>) -> Reader<Environment,State<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>> where ParameterType == State<Secondary1,Result<Result<Input,Secondary3>,Secondary2>> {
+		return Reader<Environment,State<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == State<Secondary1,Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,State<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>>) -> Reader<Environment,State<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>> where ParameterType == State<Secondary1,Result<Writer<Secondary3,Input>,Secondary2>> {
+		return Reader<Environment,State<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Output>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Output>>> where ParameterType == State<Secondary1,Writer<Secondary2,Input>> {
 		return Reader<Environment,State<Secondary1,Writer<Secondary2,Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Array<Output>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Array<Input>>> {
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Array<Output>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Array<Input>>> {
 		return Reader<Environment,State<Secondary1,Writer<Secondary2,Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Optional<Output>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Optional<Input>>> {
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Optional<Output>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Optional<Input>>> {
 		return Reader<Environment,State<Secondary1,Writer<Secondary2,Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,State<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Result<Input,Secondary3>>> {
+		return Reader<Environment,State<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,State<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == State<Secondary1,Writer<Secondary2,Writer<Secondary3,Input>>> {
 		return Reader<Environment,State<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-    func flatMapT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Output>>) -> Reader<Environment,Writer<Secondary1,Output>> where ParameterType == Writer<Secondary1,Input> {
-        return Reader<Environment,Writer<Secondary1,Output>>.init { e in
+    func flatMapT <Secondary,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary,Output>>) -> Reader<Environment,Writer<Secondary,Output>> where ParameterType == Writer<Secondary,Input> {
+        return Reader<Environment,Writer<Secondary,Output>>.init { e in
             self.run(e).flatMap { transform($0).run(e) }
         }
     }
 
-
-
-
 	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Output>>>) -> Reader<Environment,Writer<Secondary1,Array<Output>>> where ParameterType == Writer<Secondary1,Array<Input>> {
 		return Reader<Environment,Writer<Secondary1,Array<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Array<Output>>>>) -> Reader<Environment,Writer<Secondary1,Array<Array<Output>>>> where ParameterType == Writer<Secondary1,Array<Array<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Array<Output>>>>) -> Reader<Environment,Writer<Secondary1,Array<Array<Output>>>> where ParameterType == Writer<Secondary1,Array<Array<Input>>> {
 		return Reader<Environment,Writer<Secondary1,Array<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Optional<Output>>>>) -> Reader<Environment,Writer<Secondary1,Array<Optional<Output>>>> where ParameterType == Writer<Secondary1,Array<Optional<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Optional<Output>>>>) -> Reader<Environment,Writer<Secondary1,Array<Optional<Output>>>> where ParameterType == Writer<Secondary1,Array<Optional<Input>>> {
 		return Reader<Environment,Writer<Secondary1,Array<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Result<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Array<Result<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Array<Result<Secondary3,Input>>> {
-		return Reader<Environment,Writer<Secondary1,Array<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Result<Output,Secondary3>>>>) -> Reader<Environment,Writer<Secondary1,Array<Result<Output,Secondary3>>>> where ParameterType == Writer<Secondary1,Array<Result<Input,Secondary3>>> {
+		return Reader<Environment,Writer<Secondary1,Array<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Array<Writer<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Array<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Array<Writer<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Array<Writer<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Array<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Writer<Secondary1,Array<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Output>>>) -> Reader<Environment,Writer<Secondary1,Optional<Output>>> where ParameterType == Writer<Secondary1,Optional<Input>> {
 		return Reader<Environment,Writer<Secondary1,Optional<Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Array<Output>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Array<Output>>>> where ParameterType == Writer<Secondary1,Optional<Array<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Array<Output>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Array<Output>>>> where ParameterType == Writer<Secondary1,Optional<Array<Input>>> {
 		return Reader<Environment,Writer<Secondary1,Optional<Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Optional<Output>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Optional<Output>>>> where ParameterType == Writer<Secondary1,Optional<Optional<Input>>> {
+	func flatMapTTT<Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Optional<Output>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Optional<Output>>>> where ParameterType == Writer<Secondary1,Optional<Optional<Input>>> {
 		return Reader<Environment,Writer<Secondary1,Optional<Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Result<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Result<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Optional<Result<Secondary3,Input>>> {
-		return Reader<Environment,Writer<Secondary1,Optional<Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Result<Output,Secondary3>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Result<Output,Secondary3>>>> where ParameterType == Writer<Secondary1,Optional<Result<Input,Secondary3>>> {
+		return Reader<Environment,Writer<Secondary1,Optional<Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Writer<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Optional<Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Optional<Writer<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Optional<Writer<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Optional<Writer<Secondary3,Input>>> {
 		return Reader<Environment,Writer<Secondary1,Optional<Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Output>>>) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Output>>> where ParameterType == Writer<Secondary1,Result<Secondary2,Input>> {
-		return Reader<Environment,Writer<Secondary1,Result<Secondary2,Output>>>.init { e in
+	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Output,Secondary2>>>) -> Reader<Environment,Writer<Secondary1,Result<Output,Secondary2>>> where ParameterType == Writer<Secondary1,Result<Input,Secondary2>> {
+		return Reader<Environment,Writer<Secondary1,Result<Output,Secondary2>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Array<Output>>>>) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Array<Output>>>> where ParameterType == Writer<Secondary1,Result<Secondary2,Array<Input>>> {
-		return Reader<Environment,Writer<Secondary1,Result<Secondary2,Array<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Array<Output>,Secondary2>>>) -> Reader<Environment,Writer<Secondary1,Result<Array<Output>,Secondary2>>> where ParameterType == Writer<Secondary1,Result<Array<Input>,Secondary2>> {
+		return Reader<Environment,Writer<Secondary1,Result<Array<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Optional<Output>>>>) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Optional<Output>>>> where ParameterType == Writer<Secondary1,Result<Secondary2,Optional<Input>>> {
-		return Reader<Environment,Writer<Secondary1,Result<Secondary2,Optional<Output>>>>.init { e in
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Optional<Output>,Secondary2>>>) -> Reader<Environment,Writer<Secondary1,Result<Optional<Output>,Secondary2>>> where ParameterType == Writer<Secondary1,Result<Optional<Input>,Secondary2>> {
+		return Reader<Environment,Writer<Secondary1,Result<Optional<Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Result<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Writer<Secondary1,Result<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>>) -> Reader<Environment,Writer<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>> where ParameterType == Writer<Secondary1,Result<Result<Input,Secondary3>,Secondary2>> {
+		return Reader<Environment,Writer<Secondary1,Result<Result<Output,Secondary3>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Result<Secondary2,Writer<Secondary3,Input>>> {
-		return Reader<Environment,Writer<Secondary1,Result<Secondary2,Writer<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>>) -> Reader<Environment,Writer<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>> where ParameterType == Writer<Secondary1,Result<Writer<Secondary3,Input>,Secondary2>> {
+		return Reader<Environment,Writer<Secondary1,Result<Writer<Secondary3,Output>,Secondary2>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
 	func flatMapTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Output>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Output>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Input>> {
 		return Reader<Environment,Writer<Secondary1,Writer<Secondary2,Output>>>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Array<Output>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Array<Input>>> {
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Array<Output>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Array<Output>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Array<Input>>> {
 		return Reader<Environment,Writer<Secondary1,Writer<Secondary2,Array<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Optional<Output>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Optional<Input>>> {
+	func flatMapTTT<Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Optional<Output>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Optional<Output>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Optional<Input>>> {
 		return Reader<Environment,Writer<Secondary1,Writer<Secondary2,Optional<Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Result<Secondary3,Input>>> {
-		return Reader<Environment,Writer<Secondary1,Writer<Secondary2,Result<Secondary3,Output>>>>.init { e in
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Result<Input,Secondary3>>> {
+		return Reader<Environment,Writer<Secondary1,Writer<Secondary2,Result<Output,Secondary3>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
-
-
-
-
-	func flatMapTTT <Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Writer<Secondary3,Input>>> {
+	func flatMapTTT<Secondary3,Secondary2,Secondary1,Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>) -> Reader<Environment,Writer<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>> where ParameterType == Writer<Secondary1,Writer<Secondary2,Writer<Secondary3,Input>>> {
 		return Reader<Environment,Writer<Secondary1,Writer<Secondary2,Writer<Secondary3,Output>>>>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
 }
diff --git a/Sources/FunctionalKit/Result.swift b/Sources/FunctionalKit/Result.swift
index d0a385e..6fa5f70 100644
--- a/Sources/FunctionalKit/Result.swift
+++ b/Sources/FunctionalKit/Result.swift
@@ -5,6 +5,7 @@ import Abstract
 
 // sourcery: functor
 // sourcery: secondaryParameter = "Failure"
+// sourcery: secondaryParameterOnRight = true
 // sourcery: monad
 // sourcery: traversable
 // sourcery: testFunctor
@@ -12,20 +13,9 @@ import Abstract
 // sourcery: testMonad
 // sourcery: testConstruct = "success(x)"
 // sourcery: testSecondaryParameter
-public enum Result<Failure,Parameter> where Failure: Error {
-    case success(Parameter)
-    case failure(Failure)
+extension Result {
     
-    public func run() throws -> Parameter {
-        switch self {
-        case .success(let value):
-            return value
-        case .failure(let error):
-            throw error
-        }
-    }
-    
-    public func fold <A> (onSuccess: (Parameter) -> A, onFailure: (Failure) -> A) -> A {
+    public func fold <A> (onSuccess: (Success) -> A, onFailure: (Failure) -> A) -> A {
         switch self {
         case .success(let value):
             return onSuccess(value)
@@ -35,28 +25,26 @@ public enum Result<Failure,Parameter> where Failure: Error {
     }
 }
 
-extension Result: Equatable where Failure: Equatable, Parameter: Equatable {}
-
 extension Result: CoproductType {
-    public typealias LeftType = Failure
-    public typealias RightType = Parameter
+    public typealias RightType = Failure
+    public typealias LeftType = Success
     
-    public func fold<T>(onLeft: (Failure) -> T, onRight: (Parameter) -> T) -> T {
-        return fold(onSuccess: onRight, onFailure: onLeft)
+    public func fold<T>(onLeft: (Success) -> T, onRight: (Failure) -> T) -> T {
+        return fold(onSuccess: onLeft, onFailure: onRight)
     }
     
-    public static func from(coproduct: Coproduct<Failure, Parameter>) -> Result<Failure, Parameter> {
+    public static func from(coproduct: Coproduct<Success, Failure>) -> Result<Success, Failure> {
         switch coproduct {
-        case let .left(error):
+        case let .right(error):
             return .failure(error)
-        case let .right(value):
+        case let .left(value):
             return .success(value)
         }
     }
 }
 
 extension Result: TypeConstructor2 {
-    public typealias ParameterType = Parameter
+    public typealias ParameterType = Success
     public typealias SecondaryType = Failure
 }
 
@@ -67,34 +55,16 @@ extension Result: PureConstructible {
 }
 
 public extension Result {
-    typealias Generic<F,A> = Result<F,A> where F: Error
+    typealias Generic<A,F> = Result<A,F> where F: Error
 }
 
 public extension Result {
-    func map <A> (_ transform: (ParameterType) -> A) -> Result<Failure,A> {
-        switch self {
-        case let .success(value):
-            return .success(transform(value))
-        case let .failure(error):
-            return .failure(error)
-        }
-    }
-    
-    func mapError <A> (_ transform: (Failure) -> A) -> Result<A,ParameterType> {
-        switch self {
-        case let .success(value):
-            return .success(value)
-        case let .failure(error):
-            return .failure(transform(error))
-        }
-        
-    }
     
-    static func lift <A> (_ function: @escaping (ParameterType) -> A) -> (Result) -> Result<Failure,A> {
+    static func lift <A> (_ function: @escaping (ParameterType) -> A) -> (Result) -> Result<A,Failure> {
         return { $0.map(function) }
     }
     
-    static func zip <F1,A,F2,B> (_ first: Result<F1,A>, _ second: Result<F2,B>) -> Result<InclusiveError<F1,F2>,(A,B)> where Failure == InclusiveError<F1,F2>, ParameterType == (A,B) {
+    static func zip <A,F1,B,F2> (_ first: Result<A, F1>, _ second: Result<B, F2>) -> Result<(A,B),InclusiveError<F1,F2>> where Failure == InclusiveError<F1,F2>, ParameterType == (A,B) {
         switch (first, second) {
         case let (.success(leftValue), .success(rightValue)):
             return .success((leftValue,rightValue))
@@ -110,53 +80,53 @@ public extension Result {
         }
     }
     
-    static func zipMerged <A,B> (_ first: Result<Failure,A>, _ second: Result<Failure,B>) -> Result<Failure,(A,B)> where Failure: Semigroup {
+    static func zipMerged <A,B> (_ first: Result<A, Failure>, _ second: Result<B, Failure>) -> Result<(A,B), Failure> where Failure: Semigroup {
         return Generic.zip(first, second).mapError { $0.toInclusive().merged() }
     }
     
-    func apply <A> (_ transform: Result<Failure,(ParameterType) -> A>) -> Result<Failure,A> {
+    func apply <A> (_ transform: Result<(ParameterType) -> A, Failure>) -> Result<A, Failure> {
         return Generic.zip(self, transform)
             .map { value, function in function(value) }
             .mapError { $0.toInclusive().left }
     }
     
-    func applyMerged <A> (_ transform: Result<Failure,(ParameterType) -> A>) -> Result<Failure,A> where Failure: Semigroup {
-        return Result<Failure, (Parameter, (Parameter) -> A)>.zipMerged(self, transform)
+    func applyMerged <A> (_ transform: Result<(ParameterType) -> A, Failure>) -> Result<A, Failure> where Failure: Semigroup {
+        return Result<(Success, (Success) -> A), Failure>.zipMerged(self, transform)
             .map { value, function in function(value) }
     }
     
-    func call <A,B> (_ value: Result<Failure,A>) -> Result<Failure,B> where ParameterType == (A) -> B {
+    func call <A,B> (_ value: Result<A, Failure>) -> Result<B, Failure> where ParameterType == (A) -> B {
         return Generic.zip(self, value)
             .map { function, value in function(value) }
             .mapError { $0.toInclusive().left }
     }
     
-    func callMerged <A,B> (_ value: Result<Failure,A>) -> Result<Failure,B> where ParameterType == (A) -> B, Failure: Semigroup {
-        return Result<Failure, ((A) -> B, A)>.zipMerged(self, value)
+    func callMerged <A,B> (_ value: Result<A, Failure>) -> Result<B, Failure> where ParameterType == (A) -> B, Failure: Semigroup {
+        return Result<((A) -> B, A), Failure>.zipMerged(self, value)
             .map { function, value in function(value) }
     }
     
-    static func <*> <A> (lhs: Result<Failure,(ParameterType) -> A>, rhs: Result) -> Result<Failure,A> {
+    static func <*> <A> (lhs: Result<(ParameterType) -> A, Failure>, rhs: Result) -> Result<A, Failure> {
         return lhs.call(rhs)
     }
     
-    static func <*> <A> (lhs: Result<Failure,(ParameterType) -> A>, rhs: Result) -> Result<Failure,A> where Failure: Semigroup {
+    static func <*> <A> (lhs: Result<(ParameterType) -> A,Failure>, rhs: Result) -> Result<A, Failure> where Failure: Semigroup {
         return lhs.callMerged(rhs)
     }
     
-    static func lift <A,B> (_ function: @escaping (A, B) -> ParameterType) -> (Result<Failure,A>, Result<Failure,B>) -> Result {
+    static func lift <A,B> (_ function: @escaping (A, B) -> ParameterType) -> (Result<A,Failure>, Result<B,Failure>) -> Result {
         return { ap1, ap2 in
             Generic.pure(f.curry(function)) <*> ap1 <*> ap2
         }
     }
     
-    static func lift <A,B,C> (_ function: @escaping (A, B, C) -> ParameterType) -> (Result<Failure,A>, Result<Failure,B>, Result<Failure,C>) -> Result {
+    static func lift <A,B,C> (_ function: @escaping (A, B, C) -> ParameterType) -> (Result<A, Failure>, Result<B, Failure>, Result<C, Failure>) -> Result {
         return { ap1, ap2, ap3 in
             Generic.pure(f.curry(function)) <*> ap1 <*> ap2 <*> ap3
         }
     }
     
-    func joined<A>() -> Result<Failure,A> where ParameterType == Result<Failure,A> {
+    func joined<A>() -> Result<A, Failure> where ParameterType == Result<A, Failure> {
         switch self {
         case let .success(value):
             return value
@@ -165,11 +135,7 @@ public extension Result {
         }
     }
     
-    func flatMap <A> (_ transform: (ParameterType) -> Result<Failure,A>) -> Result<Failure,A> {
-        return map(transform).joined()
-    }
-    
-    func traverse <A> (_ transform: (ParameterType) -> Array<A>) -> Array<Result<Failure,A>> {
+    func traverse <A> (_ transform: (ParameterType) -> Array<A>) -> Array<Result<A, Failure>> {
         switch self {
         case let .success(value):
             return Array.pure(Generic.success) <*> transform(value)
@@ -178,7 +144,7 @@ public extension Result {
         }
     }
     
-    func traverse <A> (_ transform: (ParameterType) -> Effect<A>) -> Effect<Result<Failure,A>> {
+    func traverse <A> (_ transform: (ParameterType) -> Effect<A>) -> Effect<Result<A, Failure>> {
         switch self {
         case let .success(value):
             return Effect.pure(Generic.success) <*> transform(value)
@@ -187,7 +153,7 @@ public extension Result {
         }
     }
     
-    func traverse <A> (_ transform: (ParameterType) -> Future<A>) -> Future<Result<Failure,A>> {
+    func traverse <A> (_ transform: (ParameterType) -> Future<A>) -> Future<Result<A, Failure>> {
         switch self {
         case let .success(value):
             return Future.pure(Generic.success) <*> transform(value)
@@ -196,7 +162,7 @@ public extension Result {
         }
     }
     
-    func traverse <A> (_ transform: (ParameterType) -> Optional<A>) -> Optional<Result<Failure,A>> {
+    func traverse <A> (_ transform: (ParameterType) -> Optional<A>) -> Optional<Result<A, Failure>> {
         switch self {
         case let .success(value):
             return Optional.pure(Generic.success) <*> transform(value)
@@ -205,7 +171,7 @@ public extension Result {
         }
     }
     
-    func traverse <A,E> (_ transform: (ParameterType) -> Reader<E,A>) -> Reader<E,Result<Failure,A>> {
+    func traverse <A,E> (_ transform: (ParameterType) -> Reader<E,A>) -> Reader<E,Result<A, Failure>> {
         switch self {
         case let .success(value):
             return Reader.pure(Generic.success) <*> transform(value)
@@ -214,7 +180,7 @@ public extension Result {
         }
     }
     
-    func traverse <A,F> (_ transform: (ParameterType) -> Result<F,A>) -> Result<F,Result<Failure,A>> {
+    func traverse <A,F> (_ transform: (ParameterType) -> Result<A, F>) -> Result<Result<A, Failure>, F> {
         switch self {
         case let .success(value):
             return Generic.pure(Generic.success) <*> transform(value)
@@ -223,7 +189,7 @@ public extension Result {
         }
     }
     
-    func traverse <A,M> (_ transform: (ParameterType) -> State<M,A>) -> State<M,Result<Failure,A>> {
+    func traverse <A,M> (_ transform: (ParameterType) -> State<M,A>) -> State<M,Result<A, Failure>> {
         switch self {
         case let .success(value):
             return State.pure(Generic.success) <*> transform(value)
@@ -232,7 +198,7 @@ public extension Result {
         }
     }
     
-    func traverse <A,L> (_ transform: (ParameterType) -> Writer<L,A>) -> Writer<L,Result<Failure,A>> {
+    func traverse <A,L> (_ transform: (ParameterType) -> Writer<L,A>) -> Writer<L,Result<A, Failure>> {
         switch self {
         case let .success(value):
             return Writer.pure(Generic.success) <*> transform(value)
@@ -259,7 +225,7 @@ public extension Result {
         }
     }
     
-    func getOr(_ fromFailure: (Failure) -> Parameter) -> Parameter {
+    func getOr(_ fromFailure: (Failure) -> Success) -> Success {
         return fold(
             onSuccess: f.identity,
             onFailure: fromFailure)
@@ -274,7 +240,7 @@ public extension Result {
         }
     }
     
-    func filter(_ predicate: (Parameter) -> Bool, or onFalse: @autoclosure () -> Failure) -> Result {
+    func filter(_ predicate: (Success) -> Bool, or onFalse: @autoclosure () -> Failure) -> Result {
         return flatMap {
             if predicate($0) {
                 return .success($0)
@@ -296,7 +262,7 @@ public extension Result {
     }
     
     @discardableResult
-    func `do`(onSuccess: (Parameter) -> Void, onFailure: (Failure) -> Void) -> Result {
+    func `do`(onSuccess: (Success) -> Void, onFailure: (Failure) -> Void) -> Result {
         switch self {
         case let .success(value):
             onSuccess(value)
@@ -307,7 +273,7 @@ public extension Result {
         return self
     }
     
-    func orNil() -> Result<Failure, Optional<ParameterType>> {
+    func orNil() -> Result<Optional<ParameterType>, Failure> {
         return self
             .map(Optional.init)
             .fallback(to: nil)
@@ -319,21 +285,21 @@ public extension Result {
             onFailure: { _ in other() })
     }
     
-    func extractT <E, A> () -> Result<Failure, A> where Parameter == Coreader<E, A> {
+    func extractT <E, A> () -> Result<A, Failure> where Success == Coreader<E, A> {
         return self.map { $0.extract }
     }
     
-    func mapExtend <E, P, A> (_ transform: @escaping (E, P) -> A) -> Result<Failure, Coreader<E, A>> where Parameter == Coreader<E, P> {
+    func mapExtend <E, P, A> (_ transform: @escaping (E, P) -> A) -> Result<Coreader<E, A>, Failure> where Success == Coreader<E, P> {
         return self.map {
             $0.extend(transform)
         }
     }
     
-    func mapExtract <E, P, A> (_ transform: @escaping (P) -> A) -> Result<Failure, Coreader<E, A>> where Parameter == Coreader<E, P> {
+    func mapExtract <E, P, A> (_ transform: @escaping (P) -> A) -> Result<Coreader<E, A>, Failure> where Success == Coreader<E, P> {
         return self.mapExtend { _, value in transform(value) }
     }
     
-    func flatMapExtend <E, P, A> (_ transform: @escaping (E, P) -> Result<Failure, A>) -> Result<Failure, Coreader<E, A>> where Parameter == Coreader<E, P> {
+    func flatMapExtend <E, P, A> (_ transform: @escaping (E, P) -> Result<A, Failure>) -> Result<Coreader<E, A>, Failure> where Success == Coreader<E, P> {
         return self.flatMap { old in
             return old.extend(transform).extract.map { new in
                 old.map { _ in new }
@@ -341,14 +307,14 @@ public extension Result {
         }
     }
     
-    func flatMapExtract <E, P, A> (_ transform: @escaping (P) -> Result<Failure, A>) -> Result<Failure, Coreader<E, A>> where Parameter == Coreader<E, P> {
+    func flatMapExtract <E, P, A> (_ transform: @escaping (P) -> Result<A, Failure>) -> Result<Coreader<E, A>, Failure> where Success == Coreader<E, P> {
         return self.flatMapExtend { _, value in transform(value) }
     }
 }
 
 extension First: Error where A: Error {}
 
-extension Result: Magma where Failure: Magma, Parameter: Magma {
+extension Result: Magma where Failure: Magma, Success: Magma {
     public static func <> (lhs: Result, rhs: Result) -> Result {
         switch (lhs, rhs) {
         case (.success(let lhsValue), .success(let rhsValue)):
@@ -363,10 +329,10 @@ extension Result: Magma where Failure: Magma, Parameter: Magma {
     }
 }
 
-extension Result: Semigroup where Failure: Semigroup, Parameter: Semigroup {}
+extension Result: Semigroup where Failure: Semigroup, Success: Semigroup {}
 
-extension Result: Monoid where Failure: Semigroup, Parameter: Monoid {
-    public static var empty: Result<Failure, Parameter> {
+extension Result: Monoid where Failure: Semigroup, Success: Monoid {
+    public static var empty: Result<Success, Failure> {
         return .success(.empty)
     }
 }
diff --git a/Sources/FunctionalKit/Writer.swift b/Sources/FunctionalKit/Writer.swift
index d173961..76d01fc 100644
--- a/Sources/FunctionalKit/Writer.swift
+++ b/Sources/FunctionalKit/Writer.swift
@@ -122,7 +122,7 @@ public extension Writer {
 		return Reader.pure(f.curry(Generic.init)) <*> Reader.pure(log) <*> transform(value)
 	}
 
-	func traverse <A,F> (_ transform: (ParameterType) -> Result<F,A>) -> Result<F,Writer<Log,A>> {
+	func traverse <A,F> (_ transform: (ParameterType) -> Result<A,F>) -> Result<Writer<Log,A>,F> {
 		return Result.pure(f.curry(Generic.init)) <*> Result.pure(log) <*> transform(value)
 	}
 
diff --git a/Templates/Sources/FunctorTransformers2.stencil b/Templates/Sources/FunctorTransformers2.stencil
index 53c68e5..429bc41 100644
--- a/Templates/Sources/FunctorTransformers2.stencil
+++ b/Templates/Sources/FunctorTransformers2.stencil
@@ -1,34 +1,25 @@
 {# GLOBAL MACROS #}
-
-{% macro getSecondaryParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{ level }},{% else %}{% endif %}{% endmacro %}
-
 {% macro getMapName type %}{% if type|annotated:"customMap" %}{{ type.annotations.customMap }}{% else %}map{% endif %}{% endmacro %}
-
-{% macro getTypeName type parameter secondaryParameter %}{{ type.name }}<{{ secondaryParameter }}{{ parameter }}>{% endmacro %}
-
 {% macro checkEscaping2 type1 type2 %}{% if type1.annotations.escapingHOF %}@escaping {% elif type2.annotations.escapingHOF %}@escaping {% endif %}{% endmacro %}
+{% macro getComma type %}{% if type.annotations.secondaryParameter %},{% else %}{% endif %}{% endmacro %}
+{# GENERIC PARAMETER #}
+{% macro getDefinitionGenericParameter type %}{% if type.annotations.secondaryParameter %}Secondary{% else %}{% endif %}{% endmacro %}
+{# INPUT TYPE CONSTRAINT #}
+{% macro getInputConstraint type primary %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{# OUTPUT TYPE CONCRETE #}
+{% macro getPrimaryGenericConcreteParameter type primary %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getOutputConcreteType type1 type2 primary %}{% if type1.annotations.secondaryParameter and type1.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type1.name }}<{% call getPrimaryGenericConcreteParameter type2 primary %}{% call getComma type1 %}{{ type1.annotations.secondaryParameter }}>{% elif type1.annotations.secondaryParameter %}{{ type1.name }}<{{ type1.annotations.secondaryParameter }}{% call getComma type1 %}{% call getPrimaryGenericConcreteParameter type2 primary %}>{% else %}{{type1.name}}<{% call getPrimaryGenericConcreteParameter type2 primary %}>{% endif %}{% endmacro %}
 
 {# TRANSFORMERS #}
-
 {% for type1 in types.all|annotated:"functor" %}
-
 public extension {{ type1.name }} {
-
 {% for type2 in types.all|annotated:"functor" %}
-
-{% set type2Secondary %}{% call getSecondaryParameter type2 "2" %}{% endset %}
-{% set type2Constraint %}{% call getTypeName type2 "Input" type2Secondary %}{% endset %}
-{% set type2Concrete %}{% call getTypeName type2 "Output" type2Secondary %}{% endset %}
-
-{% set type1Secondary %}{% if type1.annotations.secondaryParameter %}{{ type1.annotations.secondaryParameter }},{% else %}{% endif %}{% endset %}
-{% set type1Concrete %}{% call getTypeName type1 type2Concrete type1Secondary %}{% endset %}
-
-	func mapT <{{ type2Secondary }}Input,Output> (_ transform: {% call checkEscaping2 type1 type2 %}(Input) -> Output) -> {{ type1Concrete }} where ParameterType == {{ type2Constraint }} {
+{% set genericSecondaryParameter %}{% call getDefinitionGenericParameter type2 %}{% call getComma type2 %}{% endset %}
+{% set inputConstraint %}{% call getInputConstraint type2 "Input" %}{% endset %}
+{% set outputType %}{% call getOutputConcreteType type1 type2 "Output" %}{% endset %}
+	func mapT <{{ genericSecondaryParameter }}Input,Output> (_ transform: {% call checkEscaping2 type1 type2 %}(Input) -> Output) -> {{ outputType }} where ParameterType == {{ inputConstraint }} {
         return {% call getMapName type1 %} { $0.{% call getMapName type2 %}(transform) }
     }
 {% endfor %}
 }
-
-
-
 {% endfor %}
diff --git a/Templates/Sources/FunctorTransformers3.stencil b/Templates/Sources/FunctorTransformers3.stencil
index 8ccb59f..98f1583 100644
--- a/Templates/Sources/FunctorTransformers3.stencil
+++ b/Templates/Sources/FunctorTransformers3.stencil
@@ -1,40 +1,31 @@
 {# GLOBAL MACROS #}
-
-{% macro getSecondaryParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{ level }},{% else %}{% endif %}{% endmacro %}
-
-{% macro getMapName type %}{% if type|annotated:"customMap" %}{{ type.annotations.customMap }}{% else %}map{% endif %}{% endmacro %}
-
-{% macro getTypeName type parameter secondaryParameter %}{{ type.name }}<{{ secondaryParameter }}{{ parameter }}>{% endmacro %}
-
 {% macro checkEscaping3 type1 type2 type3 %}{% if type1.annotations.escapingHOF %}@escaping {% elif type2.annotations.escapingHOF %}@escaping {% elif type3.annotations.escapingHOF %}@escaping {% endif %}{% endmacro %}
+{% macro getMapName type %}{% if type|annotated:"customMap" %}{{ type.annotations.customMap }}{% else %}map{% endif %}{% endmacro %}
+{% macro getComma type %}{% if type.annotations.secondaryParameter %},{% else %}{% endif %}{% endmacro %}
+{# GENERIC PARAMETER #}
+{% macro getDefinitionGenericParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{level}}{% else %}{% endif %}{% endmacro %}
+{# INPUT TYPE CONSTRAINT #}
+{% macro getFirstLevelInputConstraint type primary level %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type level %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type level %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getSecondLevelInputConstraint outerType outerLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}{% call getComma outerType %}{% call getDefinitionGenericParameter outerType outerLevel %}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{% call getDefinitionGenericParameter outerType outerLevel %}{% call getComma outerType %}{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
+{# OUTPUT TYPE CONCRETE #}
+{% macro getFirstLevelOutputConstraint type primary level %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type level %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type level %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getSecondLevelOutputConstraint outerType outerLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}{% call getComma outerType %}{% call getDefinitionGenericParameter outerType outerLevel %}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{% call getDefinitionGenericParameter outerType outerLevel %}{% call getComma outerType %}{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
+{% macro getThirdLevelOutputConstraint outerType middleType middleLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}{% call getComma outerType %}{{ outerType.annotations.secondaryParameter }}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{{ outerType.annotations.secondaryParameter }}{% call getComma outerType %}{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
 
 {# TRANSFORMERS #}
-
 {% for type1 in types.all|annotated:"functor" %}
-
 public extension {{ type1.name }} {
-
 {% for type2 in types.all|annotated:"functor" %}
 {% for type3 in types.all|annotated:"functor" %}
-
-{% set type3Secondary %}{% call getSecondaryParameter type3 "3" %}{% endset %}
-{% set type3Constraint %}{% call getTypeName type3 "Input" type3Secondary %}{% endset %}
-{% set type3Concrete %}{% call getTypeName type3 "Output" type3Secondary %}{% endset %}
-
-{% set type2Secondary %}{% call getSecondaryParameter type2 "2" %}{% endset %}
-{% set type2Constraint %}{% call getTypeName type2 type3Constraint type2Secondary %}{% endset %}
-{% set type2Concrete %}{% call getTypeName type2 type3Concrete type2Secondary %}{% endset %}
-
-{% set type1Secondary %}{% if type1.annotations.secondaryParameter %}{{ type1.annotations.secondaryParameter }},{% else %}{% endif %}{% endset %}
-{% set type1Concrete %}{% call getTypeName type1 type2Concrete type1Secondary %}{% endset %}
-
-	func mapTT <{{ type3Secondary }}{{ type2Secondary }}Input,Output> (_ transform: {% call checkEscaping3 type1 type2 type3 %}(Input) -> Output) -> {{ type1Concrete }} where ParameterType == {{ type2Constraint }}  {
+{% set genericSecondSecondaryParameter %}{% call getDefinitionGenericParameter type3 "3" %}{% call getComma type %}{% endset %}
+{% set genericFirstSecondaryParameter %}{% call getDefinitionGenericParameter type2 "2" %}{% call getComma type %}{% endset %}
+{% set inputConstraint %}{% call getSecondLevelInputConstraint type2 "2" type3 "Input" "3" %}{% endset %}
+{% set outputConcreteType %}{% call getThirdLevelOutputConstraint type1 type2 "2" type3 "Output" "3"%}{% endset %}
+	func mapTT <{{ genericSecondSecondaryParameter }}{% call getComma type3 %}{{ genericFirstSecondaryParameter }}{% call getComma type2 %}Input,Output> (_ transform: {% call checkEscaping3 type1 type2 type3 %}(Input) -> Output) -> {{ outputConcreteType }} where ParameterType == {{ inputConstraint }}  {
 		return {% call getMapName type1 %} { $0.{% call getMapName type2 %} { $0.{% call getMapName type3 %}(transform) } }
 	}
+	
 {% endfor %}
 {% endfor %}
 }
-
-
-
 {% endfor %}
diff --git a/Templates/Sources/MonadTransformers2.stencil b/Templates/Sources/MonadTransformers2.stencil
index 81223ea..435985d 100644
--- a/Templates/Sources/MonadTransformers2.stencil
+++ b/Templates/Sources/MonadTransformers2.stencil
@@ -1,40 +1,29 @@
 {# GLOBAL MACROS #}
-
-{% macro getSecondaryParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{ level }},{% else %}{% endif %}{% endmacro %}
-
 {% macro getMapName type %}{% if type|annotated:"customMap" %}{{ type.annotations.customMap }}{% else %}map{% endif %}{% endmacro %}
-
 {% macro getFlatMapName type %}{% if type|annotated:"customFlatMap" %}{{ type.annotations.customFlatMap }}{% else %}flatMap{% endif %}{% endmacro %}
-
-{% macro getTypeName type parameter secondaryParameter %}{{ type.name }}<{{ secondaryParameter }}{{ parameter }}>{% endmacro %}
-
 {% macro checkEscaping2 type1 type2 %}{% if type1.annotations.escapingHOF %}@escaping {% elif type2.annotations.escapingHOF %}@escaping {% endif %}{% endmacro %}
-
 {% macro getJoinedName type %}{% if type.annotations.alternativeJoined %}{{ type.annotations.alternativeJoined }}{% else %}joined(){% endif %}{% endmacro %}
+{% macro getComma type %}{% if type.annotations.secondaryParameter %},{% else %}{% endif %}{% endmacro %}
+{# GENERIC PARAMETER #}
+{% macro getDefinitionGenericParameter type %}{% if type.annotations.secondaryParameter %}Secondary{% else %}{% endif %}{% endmacro %}
+{# INPUT TYPE CONSTRAINT #}
+{% macro getInputConstraint type primary %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{# OUTPUT TYPE CONCRETE #}
+{% macro getPrimaryGenericConcreteParameter type primary %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getOutputConcreteType type1 type2 primary %}{% if type1.annotations.secondaryParameter and type1.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type1.name }}<{% call getPrimaryGenericConcreteParameter type2 primary %}{% call getComma type1 %}{{ type1.annotations.secondaryParameter }}>{% elif type1.annotations.secondaryParameter %}{{ type1.name }}<{{ type1.annotations.secondaryParameter }}{% call getComma type1 %}{% call getPrimaryGenericConcreteParameter type2 primary %}>{% else %}{{type1.name}}<{% call getPrimaryGenericConcreteParameter type2 primary %}>{% endif %}{% endmacro %}
 
 {# TRANSFORMERS #}
-
 {% for type1 in types.all|annotated:"functor"|annotated:"monad"|!annotated:"customTransformer" %}
-
 public extension {{ type1.name }} {
-
 {% for type2 in types.all|annotated:"functor"|annotated:"monad"|annotated:"traversable" %}
-
-{% set type2Secondary %}{% call getSecondaryParameter type2 "2" %}{% endset %}
-{% set type2Constraint %}{% call getTypeName type2 "Input" type2Secondary %}{% endset %}
-{% set type2Concrete %}{% call getTypeName type2 "Output" type2Secondary %}{% endset %}
-
-{% set type1Secondary %}{% if type1.annotations.secondaryParameter %}{{ type1.annotations.secondaryParameter }},{% else %}{% endif %}{% endset %}
-{% set type1Concrete %}{% call getTypeName type1 type2Concrete type1Secondary %}{% endset %}
-
-	func flatMapT <{{ type2Secondary }}Input,Output> (_ transform: {% call checkEscaping2 type1 type2 %}(Input) -> {{ type1Concrete }}) -> {{ type1Concrete }} where ParameterType == {{ type2Constraint }} {
-        return {% call getFlatMapName type1 %} { (value) -> {{ type1Concrete }} in
+{% set genericSecondaryParameter %}{% call getDefinitionGenericParameter type2 %}{% call getComma type2 %}{% endset %}
+{% set inputConstraint %}{% call getInputConstraint type2 "Input" %}{% endset %}
+{% set outputType %}{% call getOutputConcreteType type1 type2 "Output" %}{% endset %}
+	func flatMapT <{{ genericSecondaryParameter }}Input,Output> (_ transform: {% call checkEscaping2 type1 type2 %}(Input) -> {{ outputType }}) -> {{ outputType }} where ParameterType == {{ inputConstraint }} {
+        return {% call getFlatMapName type1 %} { (value) -> {{ outputType }} in
 			value.traverse(transform).{% call getMapName type1 %} { $0.{% call getJoinedName type2 %} }
         }
     }
 {% endfor %}
 }
-
-
-
 {% endfor %}
diff --git a/Templates/Sources/MonadTransformers3.stencil b/Templates/Sources/MonadTransformers3.stencil
index f4dcc37..ac2e571 100644
--- a/Templates/Sources/MonadTransformers3.stencil
+++ b/Templates/Sources/MonadTransformers3.stencil
@@ -1,39 +1,30 @@
 {# GLOBAL MACROS #}
-
-{% macro getSecondaryParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{ level }},{% else %}{% endif %}{% endmacro %}
-
 {% macro getMapName type %}{% if type|annotated:"customMap" %}{{ type.annotations.customMap }}{% else %}map{% endif %}{% endmacro %}
-
 {% macro getFlatMapName type %}{% if type|annotated:"customFlatMap" %}{{ type.annotations.customFlatMap }}{% else %}flatMap{% endif %}{% endmacro %}
-
-{% macro getTypeName type parameter secondaryParameter %}{{ type.name }}<{{ secondaryParameter }}{{ parameter }}>{% endmacro %}
-
 {% macro checkEscaping3 type1 type2 type3 %}{% if type1.annotations.escapingHOF %}@escaping {% elif type2.annotations.escapingHOF %}@escaping {% elif type3.annotations.escapingHOF %}@escaping {% endif %}{% endmacro %}
-
 {% macro getJoinedName type %}{% if type.annotations.alternativeJoined %}{{ type.annotations.alternativeJoined }}{% else %}joined(){% endif %}{% endmacro %}
+{% macro getComma type %}{% if type.annotations.secondaryParameter %},{% else %}{% endif %}{% endmacro %}
+{# GENERIC PARAMETER #}
+{% macro getDefinitionGenericParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{level}}{% else %}{% endif %}{% endmacro %}
+{# INPUT TYPE CONSTRAINT #}
+{% macro getFirstLevelInputConstraint type primary level %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type level %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type level %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getSecondLevelInputConstraint outerType outerLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}{% call getComma outerType %}{% call getDefinitionGenericParameter outerType outerLevel %}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{% call getDefinitionGenericParameter outerType outerLevel %}{% call getComma outerType %}{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
+{# OUTPUT TYPE CONCRETE #}
+{% macro getFirstLevelOutputConstraint type primary level %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type level %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type level %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getSecondLevelOutputConstraint outerType outerLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}{% call getComma outerType %}{% call getDefinitionGenericParameter outerType outerLevel %}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{% call getDefinitionGenericParameter outerType outerLevel %}{% call getComma outerType %}{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
+{% macro getThirdLevelOutputConstraint outerType middleType middleLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}{% call getComma outerType %}{{ outerType.annotations.secondaryParameter }}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{{ outerType.annotations.secondaryParameter }}{% call getComma outerType %}{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
 
 {# TRANSFORMERS #}
-
 {% for type1 in types.all|annotated:"functor"|annotated:"monad"|!annotated:"customTransformer" %}
-
 public extension {{ type1.name }} {
-
 {% for type2 in types.all|annotated:"functor"|annotated:"monad"|annotated:"traversable" %}
 {% for type3 in types.all|annotated:"functor"|annotated:"monad"|annotated:"traversable" %}
-
-{% set type3Secondary %}{% call getSecondaryParameter type3 "3" %}{% endset %}
-{% set type3Constraint %}{% call getTypeName type3 "Input" type3Secondary %}{% endset %}
-{% set type3Concrete %}{% call getTypeName type3 "Output" type3Secondary %}{% endset %}
-
-{% set type2Secondary %}{% call getSecondaryParameter type2 "2" %}{% endset %}
-{% set type2Constraint %}{% call getTypeName type2 type3Constraint type2Secondary %}{% endset %}
-{% set type2Concrete %}{% call getTypeName type2 type3Concrete type2Secondary %}{% endset %}
-
-{% set type1Secondary %}{% if type1.annotations.secondaryParameter %}{{ type1.annotations.secondaryParameter }},{% else %}{% endif %}{% endset %}
-{% set type1Concrete %}{% call getTypeName type1 type2Concrete type1Secondary %}{% endset %}
-
-	func flatMapTT <{{ type3Secondary }}{{ type2Secondary }}Input,Output> (_ transform: {% call checkEscaping3 type1 type2 type3 %}(Input) -> {{ type1Concrete }}) -> {{ type1Concrete }} where ParameterType == {{ type2Constraint }} {
-		return flatMapT { (value) -> {{ type1Concrete }} in
+{% set genericSecondSecondaryParameter %}{% call getDefinitionGenericParameter type3 "3" %}{% call getComma type %}{% endset %}
+{% set genericFirstSecondaryParameter %}{% call getDefinitionGenericParameter type2 "2" %}{% call getComma type %}{% endset %}
+{% set inputConstraint %}{% call getSecondLevelInputConstraint type2 "2" type3 "Input" "3" %}{% endset %}
+{% set outputConcreteType %}{% call getThirdLevelOutputConstraint type1 type2 "2" type3 "Output" "3"%}{% endset %}
+	func flatMapTT <{{ genericSecondSecondaryParameter }}{% call getComma type3 %}{{ genericFirstSecondaryParameter }}{% call getComma type2 %}Input,Output> (_ transform: {% call checkEscaping3 type1 type2 type3 %}(Input) -> {{ outputConcreteType }}) -> {{ outputConcreteType }} where ParameterType == {{ inputConstraint }} {
+		return flatMapT { (value) -> {{ outputConcreteType }} in
 			value.traverse(transform).{% call getMapName type1 %} { $0.traverse(f.identity) }.mapT { $0.{% call getJoinedName type3 %} }
 		}
 	}
diff --git a/Templates/Sources/ReaderTransformer.stencil b/Templates/Sources/ReaderTransformer.stencil
index c37fe41..3baa051 100644
--- a/Templates/Sources/ReaderTransformer.stencil
+++ b/Templates/Sources/ReaderTransformer.stencil
@@ -1,71 +1,56 @@
 {# GLOBAL MACROS #}
-
-{% macro getSecondaryParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{ level }},{% else %}{% endif %}{% endmacro %}
-
 {% macro getMapName type %}{% if type|annotated:"customMap" %}{{ type.annotations.customMap }}{% else %}map{% endif %}{% endmacro %}
-
 {% macro getFlatMapName type %}{% if type|annotated:"customFlatMap" %}{{ type.annotations.customFlatMap }}{% else %}flatMap{% endif %}{% endmacro %}
-
-{% macro getTypeName type parameter secondaryParameter %}{{ type.name }}<{{ secondaryParameter }}{{ parameter }}>{% endmacro %}
-
 {% macro checkEscaping2 type1 type2 %}{% if type1.annotations.escapingHOF %}@escaping {% elif type2.annotations.escapingHOF %}@escaping {% endif %}{% endmacro %}
-
 {% macro checkEscaping3 type1 type2 type3 %}{% if type1.annotations.escapingHOF %}@escaping {% elif type2.annotations.escapingHOF %}@escaping {% elif type3.annotations.escapingHOF %}@escaping {% endif %}{% endmacro %}
-
 {% macro checkEscaping4 type1 type2 type3 type4 %}{% if type1.annotations.escapingHOF %}@escaping {% elif type2.annotations.escapingHOF %}@escaping {% elif type3.annotations.escapingHOF %}@escaping {% elif type4.annotations.escapingHOF %}@escaping {% endif %}{% endmacro %}
+{% macro getComma type %}{% if type.annotations.secondaryParameter %},{% else %}{% endif %}{% endmacro %}
+{# GENERIC PARAMETER #}
+{% macro getDefinitionGenericParameter type level %}{% if type.annotations.secondaryParameter %}Secondary{{level}}{% else %}{% endif %}{% endmacro %}
+{# INPUT TYPE CONSTRAINT #}
+{% macro getFirstLevelInputConstraint type primary level %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type level %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type level %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getSecondLevelInputConstraint outerType outerLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}{% call getComma outerType %}{% call getDefinitionGenericParameter outerType outerLevel %}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{% call getDefinitionGenericParameter outerType outerLevel %}{% call getComma outerType %}{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getFirstLevelInputConstraint innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
+{% macro getThirdLevelInputConstraint firstType firstLevel secondType secondLevel thirdType thirdPrimary thirdLevel  %}{% if firstType.annotations.secondaryParameter and firstType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ firstType.name }}<{% call getSecondLevelInputConstraint secondType secondLevel thirdType thirdPrimary thirdLevel %}{% call getComma firstType %}{% call getDefinitionGenericParameter firstType firstLevel %}>{% elif firstType.annotations.secondaryParameter %}{{ firstType.name }}<{% call getDefinitionGenericParameter firstType firstLevel %}{% call getComma firstType %}{% call getSecondLevelInputConstraint secondType secondLevel thirdType thirdPrimary thirdLevel %}>{% else %}{{ firstType.name }}<{% call getSecondLevelInputConstraint secondType secondLevel thirdType thirdPrimary thirdLevel %}>{% endif %}{% endmacro %}
+{# OUTPUT TYPE CONCRETE #}
+{% macro getFirstLevelOutputConstraint type primary level %}{% if type.annotations.secondaryParameter and type.annotations.secondaryParameterOnRight|annotated:"true" %}{{ type.name }}<{{ primary }}{% call getComma type %}{% call getDefinitionGenericParameter type level %}>{% elif type.annotations.secondaryParameter %}{{ type.name }}<{% call getDefinitionGenericParameter type level %}{% call getComma type %}{{ primary }}>{% else %}{{ type.name }}<{{ primary }}>{% endif %}{% endmacro %}
+{% macro getSecondLevelOutputConstraint outerType outerLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}{% call getComma outerType %}{% call getDefinitionGenericParameter outerType outerLevel %}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{% call getDefinitionGenericParameter outerType outerLevel %}{% call getComma outerType %}{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getFirstLevelOutputConstraint innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
+{% macro getThirdLevelOutputConstraint outerType outerLevel middleType middleLevel innerType innerPrimary innerLevel %}{% if outerType.annotations.secondaryParameter and outerType.annotations.secondaryParameterOnRight|annotated:"true" %}{{ outerType.name }}<{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}{% call getComma outerType %}{% call getDefinitionGenericParameter outerType outerLevel %}>{% elif outerType.annotations.secondaryParameter %}{{ outerType.name }}<{% call getDefinitionGenericParameter outerType outerLevel %}{% call getComma outerType %}{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}>{% else %}{{ outerType.name }}<{% call getSecondLevelOutputConstraint middleType middleLevel innerType innerPrimary innerLevel %}>{% endif %}{% endmacro %}
 
 {# TRANSFORMERS #}
-
 public extension Reader {
-
 {% for type1 in types.all|annotated:"monad" %}
-
-{% set type1Secondary %}{% call getSecondaryParameter type1 "1" %}{% endset %}
-{% set type1Constraint %}{% call getTypeName type1 "Input" type1Secondary %}{% endset %}
-{% set type1Concrete %}{% call getTypeName type1 "Output" type1Secondary %}{% endset %}
-
-    func flatMapT <{{ type1Secondary }}Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,{{ type1Concrete }}>) -> Reader<Environment,{{ type1Concrete }}> where ParameterType == {{ type1Constraint }} {
-        return Reader<Environment,{{ type1Concrete }}>.init { e in
+	{% set genericSecondaryFlatMapTParameter %}{% call getDefinitionGenericParameter type1 "" %}{% endset %}
+	{% set inputFlatMapTConstraint %}{% call getFirstLevelInputConstraint type1 "Input" "" %}{% endset %}
+	{% set outputFlatMapTType %}{% call getFirstLevelOutputConstraint type1 "Output" "" %}{% endset %}
+    func flatMapT <{{ genericSecondaryFlatMapTParameter }}{% call getComma type1 %}Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,{{ outputFlatMapTType }}>) -> Reader<Environment,{{ outputFlatMapTType }}> where ParameterType == {{ inputFlatMapTConstraint }} {
+        return Reader<Environment,{{ outputFlatMapTType }}>.init { e in
             self.run(e).{% call getFlatMapName type1 %} { transform($0).run(e) }
         }
     }
 
 {% for type2 in types.all|annotated:"monad"|annotated:"traversable" %}
-
-{% set type2Secondary %}{% call getSecondaryParameter type2 "2" %}{% endset %}
-{% set type2Constraint %}{% call getTypeName type2 "Input" type2Secondary %}{% endset %}
-{% set type2Concrete %}{% call getTypeName type2 "Output" type2Secondary %}{% endset %}
-
-{% set type1Secondary %}{% call getSecondaryParameter type1 "1" %}{% endset %}
-{% set type1Constraint %}{% call getTypeName type1 type2Constraint type1Secondary %}{% endset %}
-{% set type1Concrete %}{% call getTypeName type1 type2Concrete type1Secondary %}{% endset %}
-
-	func flatMapTT <{{ type2Secondary }}{{ type1Secondary }}Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,{{ type1Concrete }}>) -> Reader<Environment,{{ type1Concrete }}> where ParameterType == {{ type1Constraint }} {
-		return Reader<Environment,{{ type1Concrete }}>.init { e in
+	{% set genericSecondSecondaryFlatMapTTParameter %}{% call getDefinitionGenericParameter type2 "2" %}{% call getComma type %}{% endset %}
+	{% set genericFirstSecondaryFlatMapTTParameter %}{% call getDefinitionGenericParameter type1 "1" %}{% call getComma type %}{% endset %}
+	{% set inputFlatMapTTConstraint %}{% call getSecondLevelInputConstraint type1 "1" type2 "Input" "2" %}{% endset %}
+	{% set outputFlatMapTTConcreteType %}{% call getSecondLevelOutputConstraint type1 "1" type2 "Output" "2" %}{% endset %}
+	func flatMapTT <{{ genericSecondSecondaryFlatMapTTParameter }}{% call getComma type2 %}{{ genericFirstSecondaryFlatMapTTParameter }}{% call getComma type1 %}Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,{{ outputFlatMapTTConcreteType }}>) -> Reader<Environment,{{ outputFlatMapTTConcreteType }}> where ParameterType == {{ inputFlatMapTTConstraint }} {
+		return Reader<Environment,{{ outputFlatMapTTConcreteType }}>.init { e in
 			self.run(e).flatMapT { transform($0).run(e) }
 		}
 	}
 
 {% for type3 in types.all|annotated:"monad"|annotated:"traversable" %}
-
-{% set type3Secondary %}{% call getSecondaryParameter type3 "3" %}{% endset %}
-{% set type3Constraint %}{% call getTypeName type3 "Input" type3Secondary %}{% endset %}
-{% set type3Concrete %}{% call getTypeName type3 "Output" type3Secondary %}{% endset %}
-
-{% set type2Secondary %}{% call getSecondaryParameter type2 "2" %}{% endset %}
-{% set type2Constraint %}{% call getTypeName type2 type3Constraint type2Secondary %}{% endset %}
-{% set type2Concrete %}{% call getTypeName type2 type3Concrete type2Secondary %}{% endset %}
-
-{% set type1Secondary %}{% call getSecondaryParameter type1 "1" %}{% endset %}
-{% set type1Constraint %}{% call getTypeName type1 type2Constraint type1Secondary %}{% endset %}
-{% set type1Concrete %}{% call getTypeName type1 type2Concrete type1Secondary %}{% endset %}
-
-	func flatMapTTT <{{ type3Secondary }}{{ type2Secondary }}{{ type1Secondary }}Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,{{ type1Concrete }}>) -> Reader<Environment,{{ type1Concrete }}> where ParameterType == {{ type1Constraint }} {
-		return Reader<Environment,{{ type1Concrete }}>.init { e in
+	{% set genericThirdSecondaryFlatMapTTTParameter %}{% call getDefinitionGenericParameter type3 "3" %}{% call getComma type %}{% endset %}
+	{% set genericSecondSecondaryFlatMapTTTParameter %}{% call getDefinitionGenericParameter type2 "2" %}{% call getComma type %}{% endset %}
+	{% set genericFirstSecondaryFlatMapTTTParameter %}{% call getDefinitionGenericParameter type1 "1" %}{% call getComma type %}{% endset %}
+	{% set inputFlatMapTTTConstraint %}{% call getThirdLevelInputConstraint type1 "1" type2 "2" type3 "Input" "3" %}{% endset %}
+	{% set outputFlatMapTTTConcreteType %}{% call getThirdLevelOutputConstraint type1 "1" type2 "2" type3 "Output" "3" %}{% endset %}
+	func flatMapTTT<{{ genericThirdSecondaryFlatMapTTTParameter }}{% call getComma type3 %}{{ genericSecondSecondaryFlatMapTTTParameter }}{% call getComma type2 %}{{ genericFirstSecondaryFlatMapTTTParameter }}{% call getComma type1 %}Input,Output> (_ transform: @escaping (Input) -> Reader<Environment,{{ outputFlatMapTTTConcreteType }}>) -> Reader<Environment,{{ outputFlatMapTTTConcreteType }}> where ParameterType == {{ inputFlatMapTTTConstraint }} {
+		return Reader<Environment,{{ outputFlatMapTTTConcreteType }}>.init { e in
 			self.run(e).flatMapTT { transform($0).run(e) }
 		}
 	}
-
+	
 {% endfor %}
 {% endfor %}
 {% endfor %}
diff --git a/Templates/Tests/LawsTests.stencil b/Templates/Tests/LawsTests.stencil
index cfbf6b8..6ca2c39 100644
--- a/Templates/Tests/LawsTests.stencil
+++ b/Templates/Tests/LawsTests.stencil
@@ -1,5 +1,5 @@
 {# GLOBAL MACROS #}
-{% macro getTypeName type parameter %}{{ type.name }}<{% if type|annotated:"testSecondaryParameter" %}String,{% endif %}{{ parameter }}>{% endmacro %}
+{% macro getTypeName type parameter %}{{ type.name }}{% if type|annotated:"testSecondaryParameter" and type.annotations.secondaryParameterOnRight|annotated:"true"%}<{{ parameter }},String>{% elif type|annotated:"testSecondaryParameter" %}<String,{{ parameter }}>{% else %}<{{ parameter }}>{% endif %}{% endmacro %}
 {% macro getMapName type %}{% if type|annotated:"customMap" %}{{ type.annotations.customMap }}{% else %}map{% endif %}{% endmacro %}
 {% macro getFlatMapName type %}{% if type|annotated:"customFlatMap" %}{{ type.annotations.customFlatMap }}{% else %}flatMap{% endif %}{% endmacro %}
 {% macro getCommandCall type %}{% if type|annotated:"testNeedsCommand" %}.{{ type.annotations.testNeedsCommand }}{% endif %}{% endmacro %}
diff --git a/Tests/FunctionalKitTests/LawsTests.generated.swift b/Tests/FunctionalKitTests/LawsTests.generated.swift
index a857c16..3a2a6df 100644
--- a/Tests/FunctionalKitTests/LawsTests.generated.swift
+++ b/Tests/FunctionalKitTests/LawsTests.generated.swift
@@ -600,7 +600,7 @@ class LawsTests: XCTestCase {
 
     func testResultApplicativeIdentity() {
         property("Result - Applicative Laws - Identity") <- forAll { (x: String) in
-            let a_a = Result<String,Endo<String>>.pure(f.identity)
+            let a_a = Result<Endo<String>,String>.pure(f.identity)
             let a = Result<String,String>.pure(x)
             return ((a_a <*> a) == a)
         }
@@ -608,7 +608,7 @@ class LawsTests: XCTestCase {
 
     func testResultApplicativeHomomorphism() {
         property("Result - Applicative Laws - Homomorphism") <- forAll { (af: ArrowOf<String,String>, x: String) in
-            let a_a = Result<String,Endo<String>>.pure(af.getArrow)
+            let a_a = Result<Endo<String>,String>.pure(af.getArrow)
             let a1 = Result<String,String>.pure(x)
             let a2 = Result<String,String>.pure(af.getArrow(x))
             return ((a_a <*> a1) == a2)
@@ -618,9 +618,9 @@ class LawsTests: XCTestCase {
 /*
     func testResultApplicativeInterchange() {
         property("Result - Applicative Laws - Interchange") <- forAll { (af: ArrowOf<String,String>, x: String) in
-            let a_a = Result<String,Endo<String>>.pure(af.getArrow)
+            let a_a = Result<Endo<String>,String>.pure(af.getArrow)
             let a = Result<String,String>.pure(x)
-            let a_a_a = Result<String,(@escaping Endo<String>) -> String>.pure { $0(x) }
+            let a_a_a = Result<(@escaping Endo<String>) -> String,String>.pure { $0(x) }
             return ((a_a <*> a) == (a_a_a <*> a_a))
         }
     }
@@ -628,9 +628,9 @@ class LawsTests: XCTestCase {
     func testResultApplicativeComposition() {
         property("Result - Applicative Laws - Interchange") <- forAll { (af: ArrowOf<String,String>, ag: ArrowOf<String,String>, x: String) in
             let a = Result<String,String>.pure(x)
-            let a_a1 = Result<String,Endo<String>>.pure(af.getArrow)
-            let a_a2 = Result<String,Endo<String>>.pure(ag.getArrow)
-            let a_a_a = Result<String,(@escaping Endo<String>) -> (@escaping Endo<String>) -> Endo<String>>.pure(f.curry(f.compose))
+            let a_a1 = Result<Endo<String>,String>.pure(af.getArrow)
+            let a_a2 = Result<Endo<String>,String>.pure(ag.getArrow)
+            let a_a_a = Result<(@escaping Endo<String>) -> (@escaping Endo<String>) -> Endo<String>,String>.pure(f.curry(f.compose))
             return ((a_a_a <*> a_a1 <*> a_a2 <*> a) == (a_a2 <*> (a_a1 <*> a)))
         }
     }
diff --git a/Tests/FunctionalKitTests/ResultTests.swift b/Tests/FunctionalKitTests/ResultTests.swift
index 9bd7c9c..065812a 100644
--- a/Tests/FunctionalKitTests/ResultTests.swift
+++ b/Tests/FunctionalKitTests/ResultTests.swift
@@ -11,7 +11,7 @@ class ResultTests: XCTestCase {
         case error
     }
     
-    typealias TestResultType<T> = Result<TestErrorType, T>
+    typealias TestResultType<T> = Result<T,TestErrorType>
     
     func testLiftOneArg() {
         let id: (Int) -> Int = {$0}