diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,9 @@
     renamed to *Data.Functor.Invariant.DivAp* and
     *Data.Functor.Invariant.DecAlt*.
 
+*   **v0.3.5.1**: Fixed infinite recursion bug for Tensor instances of
+    invariant `Day`/`Night`.
+
 Version 0.3.4.0
 ---------------
 
diff --git a/functor-combinators.cabal b/functor-combinators.cabal
--- a/functor-combinators.cabal
+++ b/functor-combinators.cabal
@@ -4,10 +4,10 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 29ea615f649da19336efe3cd784f64de049f92e459aea6f853605f1e4a82af91
+-- hash: 5ffab6787a63b6742f7dc3dc9eb04a4f68a6ae789f96828dbc2a2f1919fe3855
 
 name:           functor-combinators
-version:        0.3.5.0
+version:        0.3.5.1
 synopsis:       Tools for functor combinator-based program design
 description:    Tools for working with /functor combinators/: types that take functors (or
                 other indexed types) and returns a new functor that "enhances" or "mixes"
diff --git a/src/Control/Natural/IsoF.hs b/src/Control/Natural/IsoF.hs
--- a/src/Control/Natural/IsoF.hs
+++ b/src/Control/Natural/IsoF.hs
@@ -74,7 +74,7 @@
 
 -- | An isomorphism between two functors that are coercible/have the same
 -- internal representation.  Useful for newtype wrappers.
-coercedF :: (forall x. Coercible (f x) (g x), forall x. Coercible (g x) (f x)) => f <~> g
+coercedF :: forall f g. (forall x. Coercible (f x) (g x), forall x. Coercible (g x) (f x)) => f <~> g
 coercedF = isoF coerce coerce
 
 -- | Use a '<~>' by retrieving the "forward" function:
diff --git a/src/Data/HBifunctor/Associative.hs b/src/Data/HBifunctor/Associative.hs
--- a/src/Data/HBifunctor/Associative.hs
+++ b/src/Data/HBifunctor/Associative.hs
@@ -534,7 +534,7 @@
 
 appendNEINight_ :: IN.Night (Chain1 IN.Night f) (Chain1 IN.Night f) ~> Chain1 IN.Night f
 appendNEINight_ (IN.Night xs ys f g h) = case xs of
-  Done1 x                  -> More1 (IN.Night x ys f g h)
+  Done1 x                     -> More1 (IN.Night x ys f g h)
   More1 (IN.Night z zs j k l) -> More1 $
     IN.Night z (appendNEINight_ (IN.Night zs ys id Left Right))
       (B.assoc . first j . f)
diff --git a/src/Data/HBifunctor/Tensor.hs b/src/Data/HBifunctor/Tensor.hs
--- a/src/Data/HBifunctor/Tensor.hs
+++ b/src/Data/HBifunctor/Tensor.hs
@@ -78,6 +78,7 @@
 import           Control.Monad.Trans.Compose
 import           Control.Natural
 import           Control.Natural.IsoF
+import           Data.Bifunctor
 import           Data.Coerce
 import           Data.Data
 import           Data.Function
@@ -108,6 +109,7 @@
 import           Data.List.NonEmpty                        (NonEmpty(..))
 import           Data.Void
 import           GHC.Generics
+import qualified Data.Bifunctor.Assoc                      as B
 import qualified Data.Functor.Contravariant.Coyoneda       as CCY
 import qualified Data.Functor.Contravariant.Day            as CD
 import qualified Data.Functor.Contravariant.Night          as N
@@ -468,7 +470,14 @@
     elim1 = ID.elim2
     elim2 = ID.elim1
 
-    appendLB = coerce appendChain
+    appendLB (ID.Day (DivAp xs) (DivAp ys) f g) = DivAp $ case xs of
+      Done (Identity x)      -> invmap (f x) (snd . g) ys
+      More (ID.Day z zs h j) -> More $ ID.Day
+        z
+        (unDivAp $ appendLB (ID.Day (DivAp zs) (DivAp ys) (,) id))
+        (\q (r, s) -> f (h q r) s)
+        (B.assoc . first j . g)
+
     splitNE = coerce splitChain1
     splittingLB = coercedF . splittingChain . coercedF
 
@@ -496,7 +505,14 @@
     elim1 = IN.elim2
     elim2 = IN.elim1
 
-    appendLB = coerce appendChain
+    appendLB (IN.Night (DecAlt xs) (DecAlt ys) f g h) = DecAlt $ case xs of
+      Done r      -> invmap h (either (absurd . refute r) id . f) ys
+      More (IN.Night z zs j k l) -> More $ IN.Night
+        z
+        (unDecAlt $ appendLB (IN.Night (DecAlt zs) (DecAlt ys) id Left Right))
+        (B.assoc . first j . f)
+        (g . k)
+        (either (g . l) h)
     splitNE = coerce splitChain1
     splittingLB = coercedF . splittingChain . coercedF
 
diff --git a/src/Data/HFunctor/Chain/Internal.hs b/src/Data/HFunctor/Chain/Internal.hs
--- a/src/Data/HFunctor/Chain/Internal.hs
+++ b/src/Data/HFunctor/Chain/Internal.hs
@@ -372,6 +372,10 @@
 -- You can also extract the 'Ap1' part out using 'divApAp1', and extract the
 -- 'Div1' part out using 'divApDiv1'.
 --
+-- Note that this type's utility is similar to that of @'PreT' 'Ap1'@,
+-- except @'PreT' 'Ap1'@ lets you use 'Apply' typeclass methods to assemble
+-- it.
+--
 -- @since 0.3.5.0
 newtype DivAp1 f a = DivAp1_ { unDivAp1 :: Chain1 ID.Day f a }
   deriving (Invariant, HFunctor, Inject)
@@ -407,6 +411,10 @@
 -- You can also extract the 'Ap' part out using 'divApAp', and extract the
 -- 'Div' part out using 'divApDiv'.
 --
+-- Note that this type's utility is similar to that of @'PreT' 'Ap'@,
+-- except @'PreT' 'Ap'@ lets you use 'Applicative' typeclass methods to
+-- assemble it.
+--
 -- @since 0.3.5.0
 newtype DivAp f a = DivAp { unDivAp :: Chain ID.Day Identity f a }
   deriving (Invariant, HFunctor)
@@ -444,6 +452,10 @@
 -- You can also extract the 'NonEmptyF' part out using 'decAltNonEmptyF', and
 -- extract the 'Dec1' part out using 'decAltDec1'.
 --
+-- Note that this type's utility is similar to that of @'PostT' 'Dec1'@,
+-- except @'PostT' 'Dec1'@ lets you use 'Decide' typeclass methods to
+-- assemble it.
+--
 -- @since 0.3.5.0
 newtype DecAlt1 f a = DecAlt1_ { unDecAlt1 :: Chain1 IN.Night f a }
   deriving (Invariant, HFunctor, Inject)
@@ -479,6 +491,10 @@
 --
 -- You can also extract the 'ListF' part out using 'decAltListF', and
 -- extract the 'Dec' part out using 'decAltDec'.
+--
+-- Note that this type's utility is similar to that of @'PostT' 'Dec'@,
+-- except @'PostT' 'Dec'@ lets you use 'Conclude' typeclass methods to
+-- assemble it.
 --
 -- @since 0.3.5.0
 newtype DecAlt f a = DecAlt { unDecAlt :: Chain IN.Night IN.Not f a }
diff --git a/src/Data/HFunctor/Route.hs b/src/Data/HFunctor/Route.hs
--- a/src/Data/HFunctor/Route.hs
+++ b/src/Data/HFunctor/Route.hs
@@ -150,6 +150,24 @@
 -- however, you can also interpret into covariant contexts with
 -- 'preDivisibleT', 'preDiviseT', and 'preContravariantT'.
 --
+-- A useful way to use this type is to use normal methods of the underlying
+-- @t@ to assemble a final @t@, then using the 'PreT' constructor to wrap
+-- it all up.
+--
+-- @
+-- data MyType = MyType
+--      { mtInt    :: Int
+--      , mtBool   :: Bool
+--      , mtString :: String
+--      }
+--
+-- myThing :: PreT Ap MyFunctor MyType
+-- myThing = PreT $ MyType
+--     <$> injectPre mtInt    (mfInt    :: MyFunctor Int   )
+--     <*> injectPre mtBool   (mfBool   :: MyFunctor Bool  )
+--     <*> injectPre mtString (mfString :: MyFunctor STring)
+-- @
+--
 -- See 'Pre' for more information.
 newtype PreT t f a = PreT { unPreT :: t (Pre a f) a }
 
@@ -175,6 +193,17 @@
 -- You can run this normally as if it were a @t f a@ by using 'interpret';
 -- however, you can also interpret into covariant contexts with
 -- 'postPlusT', 'postAltT', and 'postFunctorT'.
+--
+-- A useful way to use this type is to use normal methods of the underlying
+-- @t@ to assemble a final @t@, then using the 'PreT' constructor to wrap
+-- it all up.
+--
+-- @
+-- myThing :: PostT Dec MyFunctor (Either Int Bool)
+-- myThing = PostT $ decided $
+--     (injectPost Left  (mfInt  :: MyFunctor Int ))
+--     (injectPost Right (mfBool :: MyFunctor Bool))
+-- @
 --
 -- See 'Post' for more information.
 newtype PostT t f a = PostT { unPostT :: t (Post a f) a }