Restyle support annotations, update stack configs

bugsnag/src/Network/Bugsnag/BeforeNotify.hs

@@ -129,7 +129,11 @@ updateEvent f = beforeNotify $ \_e event -> f event
 updateEventFromOriginalException
     :: forall e . Exception.Exception e => (e -> BeforeNotify) -> BeforeNotify
 updateEventFromOriginalException f = beforeNotify $ \e event ->
-    let bn = maybe mempty (f . Annotated.exception) $ Exception.fromException $ Exception.toException e
+    let
+        bn =
+            maybe mempty (f . Annotated.exception)
+                $ Exception.fromException
+                $ Exception.toException e
     in runBeforeNotify bn e event
 
 setGroupingHash :: Text -> BeforeNotify

bugsnag/src/Network/Bugsnag/MetaData.hs

@@ -1,15 +1,15 @@
 -- | Working with Bugsnag's 'event_metaData' field
 module Network.Bugsnag.MetaData
-  ( MetaData (..)
-  , metaData
-  ) where
+    ( MetaData(..)
+    , metaData
+    ) where
 
 import Prelude
 
-import Data.Aeson (KeyValue ((.=)), Object, Value (..), object)
+import Data.Aeson (KeyValue((.=)), Object, Value(..), object)
 import qualified Data.Aeson as Aeson
-import qualified Data.Aeson.Types as Aeson
 import qualified Data.Aeson.KeyMap
+import qualified Data.Aeson.Types as Aeson
 
 newtype MetaData = MetaData
   { unMetaData :: Object
@@ -21,24 +21,24 @@ instance Semigroup MetaData where
   --
   -- The chosen bias ensures that adding metadata in smaller scopes (later)
   -- overrides values from larger scopes.
-  MetaData x <> MetaData y = MetaData $ unionObjects y x
-   where
-    unionObjects :: Object -> Object -> Object
-    unionObjects = Data.Aeson.KeyMap.unionWith unionValues
+    MetaData x <> MetaData y = MetaData $ unionObjects y x
+      where
+        unionObjects :: Object -> Object -> Object
+        unionObjects = Data.Aeson.KeyMap.unionWith unionValues
 
-    unionValues (Object a) (Object b) = Object $ unionObjects a b
-    unionValues a _ = a
+        unionValues (Object a) (Object b) = Object $ unionObjects a b
+        unionValues a _ = a
 
 instance Monoid MetaData where
-  mempty = MetaData mempty
+    mempty = MetaData mempty
 
 -- | Construct 'MetaData' from 'Pair's
 metaData
-  :: Aeson.Key
+    :: Aeson.Key
   -- ^ The Tab within which the values will display
-  -> [Aeson.Pair]
+    -> [Aeson.Pair]
   -- ^ The Key-Values themselves
-  -> MetaData
+    -> MetaData
 metaData key = MetaData . Data.Aeson.KeyMap.fromList . pure . (key .=) . object
 
 -- $details

bugsnag/src/Network/Bugsnag/Notify.hs

@@ -5,20 +5,20 @@ module Network.Bugsnag.Notify
 
 import Prelude
 
+import Control.Exception (SomeException, fromException, toException)
 import qualified Control.Exception as Exception
-import Control.Monad ( unless, (<=<) )
+import Control.Exception.Annotated (AnnotatedException)
+import qualified Control.Exception.Annotated as Annotated
+import Control.Monad ((<=<), unless)
+import Data.Annotation (tryAnnotations)
 import Data.Bugsnag
 import Data.Bugsnag.Settings
+import Data.Foldable (fold)
+import Data.List.NonEmpty (nonEmpty)
 import Network.Bugsnag.BeforeNotify
 import Network.Bugsnag.Exception
-import Network.HTTP.Client.TLS (getGlobalManager)
-import Control.Exception.Annotated (AnnotatedException)
 import Network.Bugsnag.MetaData
-import Data.List.NonEmpty (nonEmpty)
-import Data.Foldable (fold)
-import Data.Annotation (tryAnnotations)
-import Control.Exception (SomeException, fromException, toException)
-import qualified Control.Exception.Annotated as Annotated
+import Network.HTTP.Client.TLS (getGlobalManager)
 
 notifyBugsnag :: Exception.Exception e => Settings -> e -> IO ()
 notifyBugsnag = notifyBugsnagWith mempty
@@ -35,15 +35,20 @@ reportEvent Settings {..} event = unless (null $ event_exceptions event) $ do
     either settings_onNotifyException pure result
 
 buildEvent :: Exception.Exception e => BeforeNotify -> e -> Event
-buildEvent bn e = runBeforeNotify bn e
-    $ defaultEvent { event_exceptions = [ex], event_metaData = unMetaData <$> metaDataFromException e }
+buildEvent bn e = runBeforeNotify bn e $ defaultEvent
+    { event_exceptions = [ex]
+    , event_metaData = unMetaData <$> metaDataFromException e
+    }
     where ex = bugsnagExceptionFromSomeException $ Exception.toException e
 
 metaDataFromException :: Exception.Exception e => e -> Maybe MetaData
-metaDataFromException = metaDataFromAnnotatedException <=< (fromException @(AnnotatedException SomeException) . toException)
+metaDataFromException =
+    metaDataFromAnnotatedException
+        <=< (fromException @(AnnotatedException SomeException) . toException)
 
 metaDataFromAnnotatedException :: AnnotatedException e -> Maybe MetaData
-metaDataFromAnnotatedException = fmap fold . nonEmpty . fst . tryAnnotations . Annotated.annotations
+metaDataFromAnnotatedException =
+    fmap fold . nonEmpty . fst . tryAnnotations . Annotated.annotations
 
 globalBeforeNotify :: Settings -> BeforeNotify
 globalBeforeNotify Settings {..} =