diff --git a/library/Potoki/Core/Fetch.hs b/library/Potoki/Core/Fetch.hs
--- a/library/Potoki/Core/Fetch.hs
+++ b/library/Potoki/Core/Fetch.hs
@@ -103,8 +103,10 @@
   Fetch $ \ nil just ->
   join $
   bothFetchIO
-    (atomicModifyIORef' cacheRef (\ cache -> (cache, nil)))
-    (\ (!first, !second) -> atomicModifyIORef' cacheRef (const (Just second, just first)))
+    (return nil)
+    (\ (!first, !second) -> do
+      writeIORef cacheRef (Just second)
+      return (just first))
 
 {-# INLINABLE bothFetchingFirst #-}
 bothFetchingFirst :: IORef (Maybe b) -> Fetch a -> Fetch (a, b)
@@ -112,9 +114,26 @@
   Fetch $ \ nil just ->
   join $
   firstFetchIO
-    (atomicModifyIORef' cacheRef (\ cache -> (cache, nil)))
+    (return nil)
     (\ !firstFetched -> 
       atomicModifyIORef' cacheRef
         (\ case
           Just secondCached -> (Nothing, just (firstFetched, secondCached))
           Nothing -> (Nothing, nil)))
+
+{-# INLINABLE rightCachingLeft #-}
+rightCachingLeft :: IORef (Maybe left) -> Fetch (Either left right) -> Fetch right
+rightCachingLeft cacheRef (Fetch eitherFetchIO) =
+  Fetch $ \ nil just ->
+  join $ eitherFetchIO (return nil) $ \ case
+    Right !rightInput -> return (just rightInput)
+    Left !leftInput -> writeIORef cacheRef (Just leftInput) $> nil
+
+{-# INLINABLE eitherFetchingRight #-}
+eitherFetchingRight :: IORef (Maybe left) -> Fetch right -> Fetch (Either left right)
+eitherFetchingRight cacheRef (Fetch rightFetchIO) =
+  Fetch $ \ nil just ->
+  join $ rightFetchIO (return nil) $ \ right ->
+  atomicModifyIORef' cacheRef $ \ case
+    Nothing -> (Nothing, just (Right right))
+    Just left -> (Nothing, just (Left left))
diff --git a/library/Potoki/Core/Transform.hs b/library/Potoki/Core/Transform.hs
--- a/library/Potoki/Core/Transform.hs
+++ b/library/Potoki/Core/Transform.hs
@@ -28,23 +28,25 @@
 
 instance Choice Transform where
   right' (Transform rightTransformIO) =
-    Transform $ \ (A.Fetch eitherFetchIO) -> do
+    Transform $ \ eitherFetch -> do
       fetchedLeftMaybeRef <- newIORef Nothing
-      let
-        createRightFetchIO =
-          rightTransformIO $ A.Fetch $ \ nil just -> join $ eitherFetchIO (return nil) $ \ case
-            Right !rightInput -> return (just rightInput)
-            Left !leftInput -> writeIORef fetchedLeftMaybeRef (Just leftInput) $> nil
-      rightFetchIORef <- newIORef =<< createRightFetchIO
+      rightFetchMaybeRef <- newIORef Nothing
       return $ A.Fetch $ \ nil just -> do
-        A.Fetch rightFetchIO <- readIORef rightFetchIORef
+        A.Fetch rightFetchIO <- do
+          rightFetchMaybe <- readIORef rightFetchMaybeRef
+          case rightFetchMaybe of
+            Just rightFetch -> return rightFetch
+            Nothing -> do
+              rightFetch <- rightTransformIO (A.rightCachingLeft fetchedLeftMaybeRef eitherFetch)
+              writeIORef rightFetchMaybeRef (Just rightFetch)
+              return rightFetch
         join $ rightFetchIO
           (do
             fetchedLeftMaybe <- readIORef fetchedLeftMaybeRef
             case fetchedLeftMaybe of
               Just fetchedLeft -> do
                 writeIORef fetchedLeftMaybeRef Nothing
-                writeIORef rightFetchIORef =<< createRightFetchIO
+                writeIORef rightFetchMaybeRef Nothing
                 return (just (Left fetchedLeft))
               Nothing -> return nil)
           (\ right -> return (just (Right right)))
diff --git a/potoki-core.cabal b/potoki-core.cabal
--- a/potoki-core.cabal
+++ b/potoki-core.cabal
@@ -1,7 +1,7 @@
 name:
   potoki-core
 version:
-  1.4.1
+  1.5
 synopsis:
   Low-level components of "potoki"
 description: