Drop runFold

The contract of `runFold` promised

```hs
--- If the fold has an associated exception handler, it will get a chance to
--- catch any exceptions thrown. See 'foldWithHandler' for detailed discussion.
```

but that is a contract it could not keep: after all, the whole point for introducing `foldWithHandler` in the first place was that we need to treat these handlers very carefully, simply using `handle` does not work.

It turns out we don't actually _need_ `runFold`, so deleted it altogether; I
think this clarifies the situation on the `hs-bindgen` side also (see
discussion of `topLevelFold` there).

Author: edsko

src/Clang/HighLevel/Fold.hs

@@ -8,7 +8,6 @@ module Clang.HighLevel.Fold (
     -- * Construction
   , simpleFold
   , foldWithHandler
-  , runFold
     -- * Fold-specific operations
   , foldBreak
   , foldBreakWith
@@ -177,23 +176,6 @@ foldWithHandler handler foldNext =
           Just e' -> handler curr e'
           Nothing -> liftIO $ throwIO e
 
--- | Run 'Fold'
---
--- If the fold has an associated exception handler, it will get a chance to
--- catch any exceptions thrown. See 'foldWithHandler' for detailed discussion.
-runFold :: MonadUnliftIO m => Fold m a -> CXCursor -> m (Next m a)
-runFold fold curr = withRunInIO $ \runInIO -> runFoldUsing runInIO fold curr
-
--- | Internal generalization of 'runFold'
-runFoldUsing ::
-     ( MonadIO n
-     , Functor m
-     )
-  => RunInIO m -> Fold m a -> CXCursor -> n (Next m a)
-runFoldUsing runInIO Fold{foldNext, foldHandler} curr =
-    handleUnliftUsing runInIO (fmap Continue . foldHandler curr) $
-      foldNext curr
-
 -- | Result of visiting one node
 --
 -- This is the equivalent of 'CXChildVisitResult'
@@ -487,25 +469,34 @@ clang_visitChildren root topLevelFold = withRunInIO $ \runInIO -> do
       -> IO (SimpleEnum CXChildVisitResult)
     visitor runInIO someStack current parent = do
         popUntil runInIO someStack parent
-        SomeStack stack <- readIORef someStack
-        let p = topProcessing stack
-        previousException <- partialResultsIsException (partialResults p)
+        SomeStack (stack :: Stack m x) <- readIORef someStack
+
+        let foldHandler    :: CXCursor -> SomeException -> m (Maybe x)
+            foldNext       :: CXCursor -> m (Next m x)
+            partialResults :: PartialResults x
+            Processing{
+                currentFold = Fold{foldHandler, foldNext}
+              , partialResults
+              } = topProcessing stack
 
+        previousException <- partialResultsIsException partialResults
         if previousException then
           return $ simpleEnum CXChildVisit_Continue
         else do
-          next <- Base.try $ runFoldUsing runInIO (currentFold p) current
+          next <- Base.try $
+            handleUnliftUsing runInIO (fmap Continue . foldHandler current) $
+              foldNext current
           case next of
             Right (Break ma) -> do
-              forM_ ma $ addPartialResult (partialResults p)
+              forM_ ma $ addPartialResult partialResults
               return $ simpleEnum CXChildVisit_Break
             Right (Continue ma) -> do
-              forM_ ma $ addPartialResult (partialResults p)
+              forM_ ma $ addPartialResult partialResults
               return $ simpleEnum CXChildVisit_Continue
             Right (Recurse fold summarize) -> do
               stack' <- push current fold summarize stack
               writeIORef someStack $ SomeStack stack'
               return $ simpleEnum CXChildVisit_Recurse
             Left ex -> do
-              recordException (partialResults p) ex
+              recordException partialResults ex
               return $ simpleEnum CXChildVisit_Continue

src/Clang/HighLevel/Types.hs

@@ -28,7 +28,6 @@ module Clang.HighLevel.Types (
     -- ** Construction
   , simpleFold
   , foldWithHandler
-  , runFold
     -- ** Fold-specific functionality
   , foldBreak
   , foldBreakWith