diff --git a/src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/IterateT.java b/src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/IterateT.java
index cb719060..07ee9f29 100644
--- a/src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/IterateT.java
+++ b/src/main/java/com/jnape/palatable/lambda/monad/transformer/builtin/IterateT.java
@@ -67,11 +67,11 @@
  */
 public class IterateT<M extends MonadRec<?, M>, A> implements MonadT<M, A, IterateT<M, ?>, IterateT<?, ?>> {
 
-    private final Pure<M>                                                                                     pureM;
-    private final ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M, A>>>, M>>, MonadRec<A, M>>> spine;
+    private final Pure<M>                                                                                                   pureM;
+    private final ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M>>, MonadRec<Maybe<A>, M>>> spine;
 
     private IterateT(Pure<M> pureM,
-                     ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M, A>>>, M>>, MonadRec<A, M>>> spine) {
+                     ImmutableQueue<Choice2<Fn0<MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M>>, MonadRec<Maybe<A>, M>>> spine) {
         this.pureM = pureM;
         this.spine = spine;
     }
@@ -108,10 +108,9 @@ public <MStep extends MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M>> MSte
                 thunkOrReal -> thunkOrReal.match(
                         thunk -> thunk.apply().<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>>fmap(m -> m.match(
                                 fn0(() -> just(tuple(nothing(), new IterateT<>(pureM, spine.tail())))),
-                                t -> just(t.biMap(Maybe::just,
-                                                  as -> new IterateT<>(pureM, as.spine.concat(spine.tail()))))))
-                                .coerce(),
-                        ma -> ma.fmap(a -> just(tuple(just(a), new IterateT<>(pureM, spine.tail())))).coerce()));
+                                t -> just(t.fmap(as -> new IterateT<>(pureM, as.spine.concat(spine.tail())))))),
+                        mMaybeA -> mMaybeA.fmap(maybeA -> just(tuple(maybeA, new IterateT<>(pureM, spine.tail()))))))
+                .coerce();
     }
 
     /**
@@ -121,9 +120,17 @@ public <MStep extends MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M>> MSte
      * @return the cons'ed {@link IterateT}
      */
     public final IterateT<M, A> cons(MonadRec<A, M> head) {
+        return consStep(head.fmap(Maybe::just));
+    }
+
+    public final IterateT<M, A> consStep(MonadRec<Maybe<A>, M> head) {
         return new IterateT<>(pureM, spine.pushFront(b(head)));
     }
 
+    public final IterateT<M, A> snocStep(MonadRec<Maybe<A>, M> last) {
+        return new IterateT<>(pureM, spine.pushBack(b(last)));
+    }
+
     /**
      * Add an element inside an effect to the back of this {@link IterateT}.
      *
@@ -131,7 +138,7 @@ public final IterateT<M, A> cons(MonadRec<A, M> head) {
      * @return the snoc'ed {@link IterateT}
      */
     public final IterateT<M, A> snoc(MonadRec<A, M> last) {
-        return new IterateT<>(pureM, spine.pushBack(b(last)));
+        return snocStep(last.fmap(Maybe::just));
     }
 
     /**
@@ -207,18 +214,16 @@ public <B, N extends MonadRec<?, N>> IterateT<N, B> lift(MonadRec<B, N> nb) {
      * {@inheritDoc}
      */
     @Override
-    @SuppressWarnings("RedundantTypeArguments")
     public <B> IterateT<M, B> trampolineM(
             Fn1<? super A, ? extends MonadRec<RecursiveResult<A, B>, IterateT<M, ?>>> fn) {
-        return $(withSelf(
-                (self, queued) -> suspended(
-                        () -> pureM.<IterateT<M, RecursiveResult<A, B>>, MonadRec<IterateT<M, RecursiveResult<A, B>>, M>>apply(queued)
-                                .trampolineM(q -> q.runIterateT().<RecursiveResult<IterateT<M, RecursiveResult<A, B>>, Maybe<Tuple2<B, IterateT<M, B>>>>>fmap(m -> m.match(
-                                        __ -> terminate(nothing()),
-                                        into((rr, tail) -> rr.biMap(
-                                                a -> fn.apply(a).<IterateT<M, RecursiveResult<A, B>>>coerce().concat(tail),
-                                                b -> just(tuple(b, self.apply(tail)))))))),
-                        pureM)),
+        return $(withSelf((self, queued) -> suspendStep(() -> pureM.<IterateT<M, RecursiveResult<A, B>>, MonadRec<IterateT<M, RecursiveResult<A, B>>, M>>apply(queued)
+                         .trampolineM(q -> q.runStep().fmap(m -> m.match(
+                                 __ -> terminate(nothing()),
+                                 t -> t.into((maybeRR, tail) -> maybeRR.match(__ -> recurse(tail),
+                                                                              rr -> rr.biMap(
+                                                                                      a -> fn.apply(a).<IterateT<M, RecursiveResult<A, B>>>coerce().concat(tail),
+                                                                                      b -> just(tuple(just(b), self.apply(tail))))))
+                         ))), pureM)),
                  flatMap(fn));
     }
 
@@ -227,16 +232,17 @@ public <B> IterateT<M, B> trampolineM(
      */
     @Override
     public <B> IterateT<M, B> flatMap(Fn1<? super A, ? extends Monad<B, IterateT<M, ?>>> f) {
-        return suspended(() -> maybeT(runIterateT())
-                                 .trampolineM(into((a, as) -> maybeT(
-                                         f.apply(a).<IterateT<M, B>>coerce().runIterateT()
-                                                 .flatMap(maybePair -> maybePair.match(
-                                                         fn0(() -> as.runIterateT()
-                                                                 .fmap(maybeResult -> maybeResult.fmap(RecursiveResult::recurse))),
-                                                         t -> pureM.apply(just(terminate(t.fmap(mb -> mb.concat(as.flatMap(f))))))
-                                                 )))))
-                                 .runMaybeT(),
-                         pureM);
+        return suspendStep(() -> {
+            MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M> runStep = runStep();
+            return maybeT(runStep)
+                    .trampolineM(into((maybeA, as) -> maybeT(maybeA.match(
+                            fn0(() -> runStep.pure(just(terminate(tuple(Maybe.<B>nothing(), as.flatMap(f)))))),
+                            a -> f.apply(a).<IterateT<M, B>>coerce().runStep()
+                                    .flatMap(maybePair -> maybePair.match(
+                                            fn0(() -> as.runStep().fmap(maybeResult -> maybeResult.fmap(RecursiveResult::recurse))),
+                                            t -> runStep.pure(just(terminate(t.fmap(mb -> mb.concat(as.flatMap(f))))))))))))
+                    .runMaybeT();
+        }, pureM);
     }
 
     /**
@@ -281,15 +287,18 @@ public <C extends Collection<A>, MAS extends MonadRec<C, M>> MAS toCollection(Fn
      */
     @Override
     public <B> IterateT<M, B> zip(Applicative<Fn1<? super A, ? extends B>, IterateT<M, ?>> appFn) {
-        return suspended(() -> {
-            MonadRec<Maybe<Tuple2<A, IterateT<M, A>>>, M> mmta = runIterateT();
+        return suspendStep(() -> {
+            MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M> mmta = runStep();
             return join(maybeT(mmta).zip(
-                    maybeT(appFn.<IterateT<M, Fn1<? super A, ? extends B>>>coerce().runIterateT())
-                            .fmap(into((f, fs) -> into((a, as) -> maybeT(
-                                    as.<B>fmap(f)
-                                            .cons(mmta.pure(f.apply(a)))
-                                            .concat(as.cons(mmta.pure(a)).zip(fs))
-                                            .runIterateT()))))))
+                    maybeT(appFn.<IterateT<M, Fn1<? super A, ? extends B>>>coerce().runStep())
+                            .fmap(into((maybeF, fs) -> into((maybeA, as) -> maybeF.match(
+                                    fn0(() -> maybeT(mmta.pure(just(tuple(nothing(), as.consStep(mmta.pure(maybeA)).zip(fs)))))),
+                                    f -> maybeA.match(
+                                            fn0(() -> maybeT(mmta.pure(just(tuple(nothing(), as.zip(fs.cons(mmta.pure(f)))))))),
+                                            a -> maybeT(as.<B>fmap(f)
+                                                                .cons(mmta.pure(f.apply(a)))
+                                                                .concat(as.cons(mmta.pure(a)).zip(fs))
+                                                                .runStep()))))))))
                     .runMaybeT();
         }, pureM);
     }
@@ -356,6 +365,11 @@ public static <M extends MonadRec<?, M>, A> IterateT<M, A> iterateT(
         return suspended(() -> unwrapped, Pure.of(unwrapped));
     }
 
+    public static <M extends MonadRec<?, M>, A> IterateT<M, A> fromSteps(
+            MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M> unwrapped) {
+        return new IterateT<>(Pure.of(unwrapped), ImmutableQueue.singleton(a(() -> unwrapped)));
+    }
+
     /**
      * Static factory method for creating an {@link IterateT} from a spine represented by one or more elements.
      *
@@ -405,6 +419,11 @@ public static <M extends MonadRec<?, M>, A, B> IterateT<M, A> unfold(
      */
     public static <M extends MonadRec<?, M>, A> IterateT<M, A> suspended(
             Fn0<MonadRec<Maybe<Tuple2<A, IterateT<M, A>>>, M>> thunk, Pure<M> pureM) {
+        return suspendStep(thunk.fmap(m -> m.fmap(mt -> mt.fmap(t -> t.biMapL(Maybe::just)))), pureM);
+    }
+
+    public static <M extends MonadRec<?, M>, A> IterateT<M, A> suspendStep(
+            Fn0<MonadRec<Maybe<Tuple2<Maybe<A>, IterateT<M, A>>>, M>> thunk, Pure<M> pureM) {
         return new IterateT<>(pureM, ImmutableQueue.singleton(a(thunk)));
     }