diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -46,4 +46,8 @@
 
 ## 0.6.2.0 -- 2024-01-24
 
-* Add mapOnObjects2 and mapOnArrows2
+* Add mapOnObjects2 and mapOnArrows2
+
+## 0.6.3.0 -- 2024-02-05
+
+* Add helpers for cones and cocones
diff --git a/FiniteCategories.cabal b/FiniteCategories.cabal
--- a/FiniteCategories.cabal
+++ b/FiniteCategories.cabal
@@ -14,7 +14,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             0.6.2.0
+version:             0.6.3.0
 
 -- A short (one-line) description of the package.
 synopsis: Finite categories and usual categorical constructions on them.
diff --git a/src/Math/Categories/ConeCategory.hs b/src/Math/Categories/ConeCategory.hs
--- a/src/Math/Categories/ConeCategory.hs
+++ b/src/Math/Categories/ConeCategory.hs
@@ -19,12 +19,15 @@
     -- ** Cone construcion
     cone,
     unsafeCone,
+    completeCone,
     -- ** Helper functions
     apex,
     baseCone,
     legsCone,
     universeCategoryCone,
     indexingCategoryCone,
+    precomposeConeWithMorphism,
+    postcomposeConeWithFunctor,
     topInjectionsCone,
     -- * Cone Morphism
     ConeMorphism,
@@ -40,12 +43,15 @@
     -- ** Cocone construction
     cocone,
     unsafeCocone,
+    completeCocone,
     -- ** Helper functions
     nadir,
     baseCocone,
     legsCocone,
     universeCategoryCocone,
     indexingCategoryCocone,
+    precomposeCoconeWithFunctor,
+    postcomposeCoconeWithMorphism,
     bottomInjectionsCocone,
     -- * Cocone Morphism
     CoconeMorphism,
@@ -99,9 +105,26 @@
             result = unsafeCommaObject apex One nat
             
     -- | Constructs a 'Cone' from an apex and a 'NaturalTransformation'. Does NOT check if the source of the 'NaturalTransformation' is a constant diagram on the apex. You may use this function at your own risk, consider using 'cone' if you are not sure.
+    --
+    -- If you give an incomplete natural transformation to this function, you can use 'completeCone' to complete the natural transformation.
     unsafeCone :: o2 -> NaturalTransformation c1 m1 o1 c2 m2 o2 -> Cone c1 m1 o1 c2 m2 o2
     unsafeCone apex nat = unsafeCommaObject apex One nat
     
+    -- | Given a cone with a partial underlying natural transformation, tries to complete it. You can use 'checkNaturalTransformation.legsCone' to check that the cone was correctly completed. 
+    completeCone :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cone c1 m1 o1 c2 m2 o2 -> Cone c1 m1 o1 c2 m2 o2
+    completeCone c = unsafeCommaObject (apex c) One newNat
+        where
+            nat = legsCone c
+            prevComp = components nat
+            validArrowOnTop x = [f | f <- arTo (indexingCategory nat) x, (source f) `Set.isIn` (keys' prevComp)]
+            comp x
+                | not $ null $ prevComp |?| x = prevComp |?| x
+                | not $ Set.null $ validArrowOnTop x = Just $ ((target nat) ->£ (anElement $ validArrowOnTop x)) @ (prevComp |!| (source (anElement $ validArrowOnTop x)))
+                | otherwise = Nothing
+            newComp = weakMapFromSet $ Set.catMaybes [sequence (x,comp x) | x <- ob (indexingCategory nat)]
+            newNat = unsafeNaturalTransformation (source nat) (target nat) newComp
+    
+    
     -- | Return the apex of a `Cone`.
     apex :: Cone c1 m1 o1 c2 m2 o2 -> o2
     apex = indexSource
@@ -187,7 +210,19 @@
             doms = possibleDomainsTopContained $ indexingCategoryCone c1
             maps = Set.concat2 [enumerateInjectiveMaps (\x y -> legsCone c1 =>$ x == legsCone c2 =>$ y) (set dom) (ob (indexingCategoryCone c2)) | dom <- doms]
     
+    -- | Precompose a cone with a morphism going to the apex. (Does not check that the morphism has the apex as target.)
+    precomposeConeWithMorphism :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,
+                                                        Morphism m2 o2) => 
+        Cone c1 m1 o1 c2 m2 o2 -> m2 -> Cone c1 m1 o1 c2 m2 o2
+    precomposeConeWithMorphism c m = unsafeCommaObject (source m) One (unsafeNaturalTransformation (source $ legsCone c) (target $ legsCone c) ((@ m) <$> (components $ legsCone c)))
     
+    -- | Postcompose a cone with a functor going from the base. 
+    postcomposeConeWithFunctor :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,
+                                     Category c2 m2 o2, Morphism m2 o2, Eq c2, Eq m2, Eq o2,
+                                                        Morphism m3 o3) => 
+        Cone c1 m1 o1 c2 m2 o2 -> Diagram c2 m2 o2 c3 m3 o3 -> Cone c1 m1 o1 c3 m3 o3
+    postcomposeConeWithFunctor c f = unsafeCommaObject (f ->$ (apex c)) One (f <-@<= (legsCone c))
+    
     -- -- --------------------------------
     -- -- Cocone related functions and types.
     -- -- --------------------------------
@@ -213,9 +248,25 @@
             result = unsafeCommaObject One nadir nat
             
     -- | Constructs a 'Cocone' from a nadir and a 'NaturalTransformation'. Does NOT check if the target of the 'NaturalTransformation' is a constant diagram on the nadir. You may use this function at your own risk, consider using 'cocone' if you are not sure.
+    --
+    -- If you give an incomplete natural transformation to this function, you can use 'completeCocone' to complete the natural transformation.
     unsafeCocone :: o2 -> NaturalTransformation c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c2 m2 o2
     unsafeCocone nadir nat = unsafeCommaObject One nadir nat
     
+    -- | Given a cocone with a partial underlying natural transformation, tries to complete it. You can use 'checkNaturalTransformation.legsCocone' to check that the cocone was correctly completed. 
+    completeCocone :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cocone c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c2 m2 o2
+    completeCocone cc = unsafeCommaObject One (nadir cc) newNat
+        where
+            nat = legsCocone cc
+            prevComp = components nat
+            validArrowOnBottom x = [f | f <- arFrom (indexingCategory nat) x, (target f) `Set.isIn` (keys' prevComp)]
+            comp x
+                | not $ null $ prevComp |?| x = prevComp |?| x
+                | not $ Set.null $ validArrowOnBottom x = Just $ (prevComp |!| (target (anElement $ validArrowOnBottom x))) @ ((source nat) ->£ (anElement $ validArrowOnBottom x))
+                | otherwise = Nothing
+            newComp = weakMapFromSet $ Set.catMaybes [sequence (x,comp x) | x <- ob (indexingCategory nat)]
+            newNat = unsafeNaturalTransformation (source nat) (target nat) newComp
+    
     -- | Return the nadir of a `Cocone`.
     nadir :: Cocone c1 m1 o1 c2 m2 o2 -> o2
     nadir = indexTarget
@@ -314,4 +365,17 @@
         | otherwise = set []
         where
             doms = possibleDomainsBottomContained $ indexingCategoryCocone cc1
-            maps = Set.concat2 [enumerateInjectiveMaps (\x y -> legsCocone cc1 =>$ x == legsCocone cc2 =>$ y) (set dom) (ob (indexingCategoryCocone cc2)) | dom <- doms]
+            maps = Set.concat2 [enumerateInjectiveMaps (\x y -> legsCocone cc1 =>$ x == legsCocone cc2 =>$ y) (set dom) (ob (indexingCategoryCocone cc2)) | dom <- doms]
+            
+     -- | Precompose a cocone with a functor going to the base.
+    precomposeCoconeWithFunctor :: (      Category c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,  
+                              FiniteCategory c2 m2 o2, Morphism m2 o2, Eq c2, Eq m2, Eq o2,
+                                                       Morphism m3 o3, Eq c3, Eq m3, Eq o3) =>
+        Cocone c2 m2 o2 c3 m3 o3 -> Diagram c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c3 m3 o3
+    precomposeCoconeWithFunctor cc f = unsafeCommaObject One (nadir cc) ((legsCocone cc) <=@<- f)
+    
+    -- | Postcompose a cone with a morphism going from the nadir. (Does not check that the morphism has the nadir as source.)
+    postcomposeCoconeWithMorphism :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,
+                                                         Morphism m2 o2) =>
+        Cocone c1 m1 o1 c2 m2 o2 -> m2 -> Cocone c1 m1 o1 c2 m2 o2
+    postcomposeCoconeWithMorphism cc m = unsafeCommaObject One (target m) (unsafeNaturalTransformation (source $ legsCocone cc) (target $ legsCocone cc) ((m @) <$> (components $ legsCocone cc)))
diff --git a/src/Math/Categories/FunctorCategory.hs b/src/Math/Categories/FunctorCategory.hs
--- a/src/Math/Categories/FunctorCategory.hs
+++ b/src/Math/Categories/FunctorCategory.hs
@@ -72,6 +72,8 @@
     leftWhiskering,
     (<-@<=),
     rightWhiskering,
+    -- ** Misc
+    indexingCategory,
     -- * Functor categories
     FunctorCategory(..),
     PrecomposedFunctorCategory(..),
@@ -420,6 +422,9 @@
     -- Use this constructor only if the 'NaturalTransformation' is necessarily well formed.
     unsafeNaturalTransformation :: Diagram c1 m1 o1 c2 m2 o2 -> Diagram c1 m1 o1 c2 m2 o2 -> Map o1 m2 -> NaturalTransformation c1 m1 o1 c2 m2 o2
     unsafeNaturalTransformation s t c = NaturalTransformation{srcNT = s, tgtNT = t, components = c}
+    
+    indexingCategory :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => NaturalTransformation c1 m1 o1 c2 m2 o2 -> c1
+    indexingCategory = src.source
     
     -- Functor Category