         switch result
         {
         case let .Success(loadResult):
-            infoState.modify({ current in
-                let newState = InfoLoaderState(
-                    loaderState: LoaderState(
-                        elements: combine(current: current.loaderState.elements, new: loadResult.elements),
-                        nextPageState: nextPageStateForSuccess(
-                            current: current.loaderState.nextPageState,
-                            mutation: loadResult.nextPageHasMore
+            modifyStateForPageCompletion(
+                transform: { current in
+                    InfoLoaderState(
+                        loaderState: LoaderState(
+                            elements: combine(current: current.loaderState.elements, new: loadResult.elements),
+                            nextPageState: nextPageStateForSuccess(
+                                current: current.loaderState.nextPageState,
+                                mutation: loadResult.nextPageHasMore
+                            ),
+                            previousPageState: previousPageStateForSuccess(
+                                current: current.loaderState.previousPageState,
+                                mutation: loadResult.previousPageHasMore
+                            )
                         ),
-                        previousPageState: previousPageStateForSuccess(
-                            current: current.loaderState.previousPageState,
-                            mutation: loadResult.previousPageHasMore
-                        )
-                    ),
-                    nextInfo: loadResult.nextPageInfo.value ?? current.nextInfo,
-                    previousInfo: loadResult.previousPageInfo.value ?? current.previousInfo
-                )
-
-                eventsPipe.1.sendNext(pageEventForLoaded(newState.loaderState, current.loaderState, loadResult.elements))
-
-                return newState
-            })
+                        nextInfo: loadResult.nextPageInfo.value ?? current.nextInfo,
+                        previousInfo: loadResult.previousPageInfo.value ?? current.previousInfo
+                    )
+                },
+                pageEvent: { current, previous in loaderEventForLoaded(current, previous, loadResult.elements) }
+            )
 
         case let .Failure(error):
-            infoState.modify({ current in
-                let newState = InfoLoaderState(
-                    loaderState: LoaderState(
-                        elements: current.loaderState.elements,
-                        nextPageState: nextPageStateForFailure(
-                            current: current.loaderState.nextPageState,
-                            error: error
+            modifyStateForPageCompletion(
+                transform: { current in
+                    InfoLoaderState(
+                        loaderState: LoaderState(
+                            elements: current.loaderState.elements,
+                            nextPageState: nextPageStateForFailure(
+                                current: current.loaderState.nextPageState,
+                                error: error
+                            ),
+                            previousPageState: previousPageStateForFailure(
+                                current: current.loaderState.previousPageState,
+                                error: error
+                            )
                         ),
-                        previousPageState: previousPageStateForFailure(
-                            current: current.loaderState.previousPageState,
-                            error: error
-                        )
-                    ),
-                    nextInfo: current.nextInfo,
-                    previousInfo: current.previousInfo
-                )
-
-                eventsPipe.1.sendNext(pageEventForFailed(newState.loaderState, current.loaderState))
-
-                return newState
-            })
+                        nextInfo: current.nextInfo,
+                        previousInfo: current.previousInfo
+                    )
+                },
+                pageEvent: loaderEventForFailed
+            )
         }
     }
 }


extension InfoStrategyArrayLoader
{
    // MARK: - Load Request Completion
    private typealias PageResult = Result<InfoLoadResult<Element, Info>, Error>
    private typealias PageStateForSuccess = (current: PageState<Error>, mutation: Mutation<Bool>) -> PageState<Error>
    private typealias PageStateForFailure = (current: PageState<Error>, error: Error) -> PageState<Error>

    static func currentIfNoMutation(current current: PageState<Error>, mutation: Mutation<Bool>) -> PageState<Error>
    {
        return mutation.value.map({ hasMore in hasMore ? .HasMore : .Completed }) ?? current
    }

    static func hasMoreIfNoMutation(current current: PageState<Error>, mutation: Mutation<Bool>) -> PageState<Error>
    {
        return mutation.value.map({ hasMore in hasMore ? .HasMore : .Completed }) ?? .HasMore
    }

    private func nextPageCompletion(result result: PageResult)
    {
        pageCompletion(
            result: result,
            combine: { current, new in current + new } ,
            pageEventForLoaded: LoaderEvent<Element, Error>.NextPageLoaded,
            pageEventForFailed: LoaderEvent.NextPageFailed,
            nextPageStateForSuccess: InfoStrategyArrayLoader.hasMoreIfNoMutation,
            previousPageStateForSuccess: InfoStrategyArrayLoader.currentIfNoMutation,
            nextPageStateForFailure: { _, error in .Failed(error) },

        )
    }


    /// Completes loading of the previous page.
    ///
    /// - parameter result: The result from loading the previous page.
    private func previousPageCompletion(result result: PageResult)
    {
        pageCompletion(
            result: result,
            combine: { current, new in new + current },
            loaderEventForLoaded: LoaderEvent<Element, Error>.PreviousPageLoaded,
            loaderEventForFailed: LoaderEvent.PreviousPageFailed,
            nextPageStateForSuccess: InfoStrategyArrayLoader.currentIfNoMutation,
            previousPageStateForSuccess: InfoStrategyArrayLoader.hasMoreIfNoMutation,
            nextPageStateForFailure: { current, _ in current },
