diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,11 @@
+0.0.4
+
+* **BREAKING**: Removed BOM (Bureau of Meteorology) support - NOAA only
+* **BREAKING**: Removed functions: `getBOMTAF`, `getAllMETAR`, `getAllTAF`
+* **BREAKING**: Removed module: `Data.Aviation.Metar.BOMTAFResult`
+* Updated for GHC 9.6.7 compatibility
+* Relaxed dependency bounds
+
 0.0.3
 
 * tgftp.nws.noaa.gov moved to forcing https, so use wreq library
diff --git a/metar.cabal b/metar.cabal
--- a/metar.cabal
+++ b/metar.cabal
@@ -1,16 +1,16 @@
 name:               metar
-version:            0.0.3
+version:            0.0.4
 license:            BSD3
 license-file:       LICENCE
 author:             Tony Morris <ʇǝu˙sıɹɹoɯʇ@sıɹɹoɯʇ>
 maintainer:         Tony Morris <ʇǝu˙sıɹɹoɯʇ@sıɹɹoɯʇ>
-copyright:          Copyright (c) 2018, Tony Morris
-synopsis:           Australian METAR
+copyright:          Copyright (c) 2018-2026, Tony Morris
+synopsis:           METAR from NOAA
 category:           Data, Aviation
-description:       
-  Obtain Australian METAR from Bureau of Meteorology (BOM).
+description:
+  Obtain METAR observations from NOAA.
   .
-  If that fails, get the METAR from NOAA.
+  Supports ICAO airport codes available in the NOAA database.
   .
   <<https://i.imgur.com/VGTogB8.gif>>
 homepage:           https://github.com/tonymorris/metar
@@ -29,17 +29,14 @@
 
   build-depends:
                     base >= 4.8 && < 5
-                    , bytestring >= 0.10 && < 0.11
-                    , http-client >= 0.5 && < 0.6
+                    , bytestring >= 0.10 && < 0.13
+                    , http-client >= 0.5 && < 0.8
                     , HTTP >= 4000 && < 5000
-                    , lens >= 4 && < 5
-                    , network-uri >= 2.6 && < 3
-                    , semigroups >= 0.9 && < 0.19
-                    , semigroupoids >= 5.2 && < 6
-                    , tagsoup >= 0.13 && < 0.15
-                    , tagsoup-selection >= 0.1 && < 0.2
-                    , transformers >= 0.5 && < 0.6
-                    , deriving-compat >= 0.5 && < 0.6
+                    , lens >= 4 && < 6
+                    , semigroups >= 0.9 && < 0.21
+                    , semigroupoids >= 5.2 && < 7
+                    , transformers >= 0.5 && < 0.7
+                    , deriving-compat >= 0.5 && < 0.7
                     , wreq >= 0.5 && < 0.6
 
   ghc-options:
@@ -54,9 +51,8 @@
 
   exposed-modules:
                     Data.Aviation.Metar
-                    , Data.Aviation.Metar.BOMTAFResult
-                    , Data.Aviation.Metar.TAFResult
-                    , Data.Aviation.Metar.TAFResultT
+                    , Data.Aviation.Metar.METARResult
+                    , Data.Aviation.Metar.METARResultT
 
 executable          metar
   main-is:
@@ -80,14 +76,14 @@
 
 test-suite          tests
 
-  build-depends:      QuickCheck >=2.9.2 && <2.13
+  build-depends:      QuickCheck >=2.9.2
                     , base >=4.8 && < 5
-                    , checkers >=0.4.6 && <0.5
+                    , checkers >=0.4.6
                     , metar
-                    , lens >=4 && <4.18
-                    , tasty >=0.11 && <1.2
-                    , tasty-hunit >=0.9 && <0.11
-                    , tasty-quickcheck >=0.8.4 && <0.11
+                    , lens >=4
+                    , tasty >=0.11
+                    , tasty-hunit >=0.9
+                    , tasty-quickcheck >=0.8.4
 
   type:             
                     exitcode-stdio-1.0
diff --git a/src/Data/Aviation/Metar.hs b/src/Data/Aviation/Metar.hs
--- a/src/Data/Aviation/Metar.hs
+++ b/src/Data/Aviation/Metar.hs
@@ -3,10 +3,7 @@
 {-# LANGUAGE CPP #-}
 
 module Data.Aviation.Metar(
-  getBOMTAF
-, getNOAAMETAR
-, getAllMETAR
-, getAllTAF
+  getNOAAMETAR
 , runMETAR
 ) where
 
@@ -15,104 +12,27 @@
 import Control.Exception(catch)
 import Control.Lens(view, _Wrapped, (&), (.~), (^.))
 import Control.Monad(Monad((>>=)))
-import Data.Aviation.Metar.BOMTAFResult(BOMTAFResponse(BOMTAFResponse), bomMETAR, bomTAF)
-import Data.Aviation.Metar.TAFResult(TAFResult(ConnErrorResult, ParseErrorResult, TAFResultValue))
-import Data.Aviation.Metar.TAFResultT(TAFResultT(TAFResultT))
+import Data.Aviation.Metar.METARResult(METARResult(ConnErrorResult, ParseErrorResult, METARResultValue))
+import Data.Aviation.Metar.METARResultT(METARResultT(METARResultT))
 import Data.ByteString.Lazy(ByteString)
-import Data.ByteString.Lazy.Char8(unpack)
+import qualified Data.ByteString.Lazy.Char8 as BS
 import Data.Char(toUpper)
 import Data.Either(Either(Left, Right))
-import Data.Foldable(length)
 import Data.Function(($))
 import Data.Functor(fmap)
-import Data.List(intercalate)
 import Data.Maybe(Maybe(Nothing, Just))
-import Data.String(String, lines)
+import Data.String(String)
 import Data.Semigroup((<>))
-import Network.HTTP(Request, Response, setHeaders, setRequestBody, mkRequest, RequestMethod(POST), Header(Header), HeaderName(..), rspBody, simpleHTTP)
 import Network.HTTP.Client(HttpException)
 import Network.Stream(ConnError(ErrorMisc))
-import Network.URI(URI(URI), URIAuth(URIAuth))
 import Network.Wreq(getWith, defaults, headers, Options, responseBody)
 import qualified Network.Wreq as Wreq(Response)
 import Prelude(show)
 import System.IO(IO, hPutStrLn, putStrLn, stderr)
-import Text.HTML.TagSoup(Tag(TagText))
-import Text.HTML.TagSoup.Tree(TagTree(TagBranch, TagLeaf), parseTree)
 
-withResult ::
-  (r -> Maybe a) ->
-  Either ConnError r ->
-  TAFResult a
-withResult _ (Left e) =
-  ConnErrorResult e
-withResult k (Right s) =
-  case k s of
-    Nothing ->
-      ParseErrorResult
-    Just z ->
-      TAFResultValue z
-
-getBOMTAF ::
-  String
-  -> TAFResultT IO BOMTAFResponse
-getBOMTAF =
-  let mkTAFResponse ::
-        [TagTree String]
-        -> Maybe BOMTAFResponse
-      mkTAFResponse (TagBranch "h3" [] [TagLeaf (TagText title)] : TagBranch "p" [("class","product")] tafs : TagBranch "p" [("class","product")] metars:_) =
-        let tagTexts q =
-              q >>= \r ->
-                case r of
-                  TagLeaf (TagText v) ->
-                    [v]
-                  _ ->
-                    []
-        in  Just (BOMTAFResponse title (tagTexts tafs) (tagTexts metars))
-      mkTAFResponse _ =
-        Nothing
-      request ::
-        String
-        -> Request String
-      request yxxx =
-        let reqBody =
-              "keyword=" <> yxxx <> "&type=search&page=TAF"
-        in  setHeaders
-              (
-                setRequestBody
-                  (
-                    mkRequest
-                      POST
-                      (URI "http" (Just (URIAuth "" "www.bom.gov.au" "")) "/aviation/php/process.php" "" "")
-                  )
-                  ("application/x-www-form-urlencoded", reqBody)
-              )
-              [
-                Header HdrHost                        "www.bom.gov.au"
-              , Header HdrUserAgent                   "tonymorris/metar"
-              , Header HdrAccept                      "*/*"
-              , Header HdrAcceptLanguage              "en-US,en;q=0.5"
-              , Header HdrAcceptEncoding              "text/html"
-              , Header HdrReferer                     "http://www.bom.gov.au/aviation/forecasts/taf/"
-              , Header HdrConnection                  "keep-alive"
-              , Header HdrContentType                 "application/x-www-form-urlencoded"
-              , Header HdrContentLength               (show (length reqBody))
-              , Header HdrCookie                      "check=ok; bom_meteye_windspeed_units_knots=yes"
-              , Header HdrPragma                      "no-cache"
-              , Header HdrCacheControl                "no-cache"
-              , Header (HdrCustom "DNT")              "1"
-              , Header (HdrCustom "X-Requested-With") "XMLHttpRequest"
-              ]
-      respTAF ::
-        Response String
-        -> Maybe BOMTAFResponse
-      respTAF =
-        mkTAFResponse . parseTree . rspBody
-  in  TAFResultT . fmap (withResult respTAF) . simpleHTTP . request
-
 getNOAAMETAR ::
   String
-  -> TAFResultT IO String
+  -> METARResultT IO String
 getNOAAMETAR =
   let options ::
         Options
@@ -165,23 +85,14 @@
         Wreq.Response ByteString
         -> Maybe String
       respMETAR r =
-        case lines . unpack $ r ^. responseBody of
-          [_, r'] -> Just r'
+        case BS.lines (r ^. responseBody) of
+          [_, r'] -> Just (BS.unpack r')
           _ -> Nothing
-  in TAFResultT . fmap (withResult respMETAR) . request
-
-getAllMETAR ::
-  String
-  -> TAFResultT IO [String]
-getAllMETAR x = 
-  fmap (view bomMETAR) (getBOMTAF x) <>
-  fmap pure (getNOAAMETAR x)
-
-getAllTAF ::
-  String
-  -> TAFResultT IO [String]
-getAllTAF x = 
-  fmap (view bomTAF) (getBOMTAF x)
+  in METARResultT . fmap (\result -> case result of
+        Left e -> ConnErrorResult e
+        Right response -> case respMETAR response of
+          Nothing -> ParseErrorResult
+          Just metar -> METARResultValue metar) . request
 
 runMETAR ::
   [String]
@@ -194,10 +105,10 @@
           do  putStrLn ("metar version " <> VERSION_metar)
               stderr' "enter an argument (ICAO code)"
         (r:_) ->
-          let s = view _Wrapped (fmap (intercalate "\n") (getAllMETAR r))
+          let s = view _Wrapped (getNOAAMETAR r)
           in  s >>= \s' ->
               case s' of
-                TAFResultValue a ->
+                METARResultValue a ->
                   putStrLn a
                 ParseErrorResult ->
                   stderr' ("No METAR for " <> r)
diff --git a/src/Data/Aviation/Metar/BOMTAFResult.hs b/src/Data/Aviation/Metar/BOMTAFResult.hs
deleted file mode 100644
--- a/src/Data/Aviation/Metar/BOMTAFResult.hs
+++ /dev/null
@@ -1,22 +0,0 @@
-{-# LANGUAGE NoImplicitPrelude #-}
-{-# LANGUAGE TemplateHaskell #-}
-
-module Data.Aviation.Metar.BOMTAFResult where
-
-import Control.Lens(makeClassy)
-import Data.Eq(Eq)
-import Data.Ord(Ord)
-import Data.String(String)
-import Prelude(Show)
-
-data BOMTAFResponse =
-  BOMTAFResponse {
-    _bomTitle ::
-      String
-  , _bomTAF ::
-      [String]
-  , _bomMETAR ::
-      [String]
-  } deriving (Eq, Ord, Show)
-
-makeClassy ''BOMTAFResponse
diff --git a/src/Data/Aviation/Metar/METARResult.hs b/src/Data/Aviation/Metar/METARResult.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Aviation/Metar/METARResult.hs
@@ -0,0 +1,96 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Data.Aviation.Metar.METARResult where
+
+import Control.Applicative(Applicative(pure, (<*>)))
+import Control.Lens(makeClassy, makeClassyPrisms)
+import Control.Monad(Monad(return, (>>=)))
+import Data.Eq(Eq)
+import Data.Eq.Deriving(deriveEq1)
+import Data.Foldable(Foldable(foldr))
+import Data.Functor(Functor(fmap), (<$>))
+import Data.Functor.Apply(Apply((<.>)))
+import Data.Functor.Bind(Bind((>>-)))
+import Data.Functor.Extend(Extend(duplicated))
+import Data.Traversable(Traversable(traverse))
+import Network.Stream(ConnError)
+import Prelude(Show)
+import Text.Show.Deriving(deriveShow1)
+
+data METARResult a =
+  ConnErrorResult ConnError
+  | ParseErrorResult
+  | METARResultValue a
+  deriving (Eq, Show)
+
+makeClassy ''METARResult
+makeClassyPrisms ''METARResult
+deriveEq1 ''METARResult
+deriveShow1 ''METARResult
+
+instance Functor METARResult where
+  fmap _ (ConnErrorResult e) =
+    ConnErrorResult e
+  fmap _ ParseErrorResult =
+    ParseErrorResult
+  fmap f (METARResultValue a) =
+    METARResultValue (f a)
+
+instance Apply METARResult where
+  ConnErrorResult e <.> _ =
+    ConnErrorResult e
+  ParseErrorResult <.> _ =
+    ParseErrorResult
+  METARResultValue f <.> METARResultValue a =
+    METARResultValue (f a)
+  METARResultValue _ <.> ConnErrorResult e =
+    ConnErrorResult e
+  METARResultValue _ <.> ParseErrorResult =
+    ParseErrorResult
+
+instance Applicative METARResult where
+  pure =
+    METARResultValue
+  (<*>) =
+    (<.>)
+
+instance Bind METARResult where
+  ConnErrorResult e >>- _ =
+    ConnErrorResult e
+  ParseErrorResult >>- _ =
+    ParseErrorResult
+  METARResultValue a >>- f =
+    f a
+
+instance Monad METARResult where
+  return =
+    pure
+  (>>=) =
+    (>>-)
+
+instance Foldable METARResult where
+  foldr f z (METARResultValue a) =
+    f a z
+  foldr _ z (ConnErrorResult _ ) =
+    z
+  foldr _ z ParseErrorResult =
+    z
+
+instance Traversable METARResult where
+  traverse f (METARResultValue a) =
+    METARResultValue <$> f a
+  traverse _ (ConnErrorResult e) =
+    pure (ConnErrorResult e)
+  traverse _ ParseErrorResult =
+    pure ParseErrorResult
+
+instance Extend METARResult where
+  duplicated (METARResultValue a) =
+    METARResultValue (METARResultValue a)
+  duplicated (ConnErrorResult e) =
+    ConnErrorResult e
+  duplicated ParseErrorResult =
+    ParseErrorResult
diff --git a/src/Data/Aviation/Metar/METARResultT.hs b/src/Data/Aviation/Metar/METARResultT.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Aviation/Metar/METARResultT.hs
@@ -0,0 +1,121 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+
+module Data.Aviation.Metar.METARResultT where
+
+import Control.Applicative(Applicative(pure, (<*>)))
+import Control.Category((.))
+import Control.Monad(Monad(return, (>>=)), ap)
+import Data.Aviation.Metar.METARResult(METARResult(METARResultValue, ConnErrorResult, ParseErrorResult))
+import Data.Eq(Eq((==)))
+import Data.Foldable(Foldable(foldr))
+import Data.Functor(Functor(fmap), (<$>))
+import Data.Functor.Alt(Alt((<!>)))
+import Data.Functor.Apply(Apply((<.>)))
+import Data.Functor.Bind(Bind((>>-)))
+import Data.Functor.Classes(Eq1, Show1, eq1, showsPrec1)
+import Data.Functor.Extend(Extend(duplicated))
+import Data.Ord((>))
+import Data.Semigroup(Semigroup((<>)))
+import Control.Lens hiding ((<.>))
+import Control.Monad.IO.Class(MonadIO(liftIO))
+import Control.Monad.Trans.Class(MonadTrans(lift))
+import Data.Eq.Deriving(deriveEq1)
+import Prelude(Show(showsPrec), showParen, showString)
+import Text.Show.Deriving(deriveShow1)
+
+newtype METARResultT f a =
+  METARResultT
+    (f (METARResult a))
+
+makeClassy ''METARResultT
+makeWrapped ''METARResultT
+
+instance (Eq a, Eq1 f) => Eq (METARResultT f a) where
+  METARResultT x == METARResultT y =
+    eq1 x y
+
+instance (Show a, Show1 f) => Show (METARResultT f a) where
+  showsPrec n (METARResultT x) =
+    showParen (n > 10) (showString "TafResultT " . showsPrec1 n x)
+
+deriveEq1 ''METARResultT
+deriveShow1 ''METARResultT
+
+instance Functor f => Functor (METARResultT f) where
+  fmap f (METARResultT x) =
+    METARResultT (fmap (fmap f) x)
+
+instance Monad f => Apply (METARResultT f) where
+  (<.>) =
+    ap
+
+instance Monad f => Applicative (METARResultT f) where
+  pure =
+    METARResultT . pure . pure
+  (<*>) =
+    ap
+
+instance Monad f => Bind (METARResultT f) where
+  (>>-) =
+    (>>=)
+
+instance Monad f => Monad (METARResultT f) where
+  return =
+    pure
+  METARResultT x >>= f =
+    METARResultT
+      (
+        x >>= \x' ->
+        case x' of
+          METARResultValue x'' ->
+            let METARResultT r = f x''
+            in  r
+          ConnErrorResult e ->
+            pure (ConnErrorResult e)
+          ParseErrorResult ->
+            pure ParseErrorResult
+      )
+
+instance Foldable f => Foldable (METARResultT f) where
+  foldr f z (METARResultT x) =
+    foldr (\a b -> foldr f b a) z x
+
+instance Traversable f => Traversable (METARResultT f) where
+  traverse f (METARResultT x) =
+    METARResultT <$> traverse (traverse f) x
+
+instance Monad f => Alt (METARResultT f) where
+  METARResultT x <!> METARResultT y =
+    METARResultT
+      (
+        x >>= \x' ->
+        case x' of
+          METARResultValue x'' ->
+            pure (METARResultValue x'')
+          ConnErrorResult _ ->
+            y
+          ParseErrorResult ->
+            y
+      )
+
+instance Extend f => Extend (METARResultT f) where
+  duplicated (METARResultT x) =
+    METARResultT (fmap (METARResultValue . METARResultT) (duplicated x))
+
+instance MonadIO f => MonadIO (METARResultT f) where
+  liftIO =
+    METARResultT . liftIO . fmap pure
+
+instance MonadTrans METARResultT where
+  lift =
+    METARResultT . fmap pure
+
+instance Monad f => Semigroup (METARResultT f a) where
+  (<>) =
+    (<!>)
diff --git a/src/Data/Aviation/Metar/TAFResult.hs b/src/Data/Aviation/Metar/TAFResult.hs
deleted file mode 100644
--- a/src/Data/Aviation/Metar/TAFResult.hs
+++ /dev/null
@@ -1,110 +0,0 @@
-{-# LANGUAGE NoImplicitPrelude #-}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE FlexibleInstances #-}
-
-module Data.Aviation.Metar.TAFResult where
-
-import Control.Applicative(Applicative(pure, (<*>)))
-import Control.Lens(makeClassy, makeClassyPrisms)
-import Control.Monad(Monad(return, (>>=)))
-import Data.Eq(Eq)
-import Data.Eq.Deriving(deriveEq1)
-import Data.Foldable(Foldable(foldr))
-import Data.Functor(Functor(fmap), (<$>))
-import Data.Functor.Alt(Alt((<!>)))
-import Data.Functor.Apply(Apply((<.>)))
-import Data.Functor.Bind(Bind((>>-)))
-import Data.Functor.Extend(Extend(duplicated))
-import Data.Semigroup(Semigroup((<>)))
-import Data.Traversable(Traversable(traverse))
-import Network.Stream(ConnError)
-import Prelude(Show)
-import Text.Show.Deriving(deriveShow1)
-
-data TAFResult a =
-  ConnErrorResult ConnError
-  | ParseErrorResult
-  | TAFResultValue a
-  deriving (Eq, Show)
-
-makeClassy ''TAFResult
-makeClassyPrisms ''TAFResult
-deriveEq1 ''TAFResult
-deriveShow1 ''TAFResult
-
-instance Functor TAFResult where
-  fmap _ (ConnErrorResult e) =
-    ConnErrorResult e
-  fmap _ ParseErrorResult =
-    ParseErrorResult
-  fmap f (TAFResultValue a) =
-    TAFResultValue (f a)
-
-instance Apply TAFResult where
-  ConnErrorResult e <.> _ =
-    ConnErrorResult e
-  ParseErrorResult <.> _ =
-    ParseErrorResult
-  TAFResultValue f <.> TAFResultValue a =
-    TAFResultValue (f a)
-  TAFResultValue _ <.> ConnErrorResult e =
-    ConnErrorResult e
-  TAFResultValue _ <.> ParseErrorResult =
-    ParseErrorResult
-
-instance Applicative TAFResult where
-  pure =
-    TAFResultValue
-  (<*>) =
-    (<.>)
-
-instance Bind TAFResult where
-  ConnErrorResult e >>- _ =
-    ConnErrorResult e
-  ParseErrorResult >>- _ =
-    ParseErrorResult
-  TAFResultValue a >>- f =
-    f a
-
-instance Monad TAFResult where
-  return =
-    pure
-  (>>=) =
-    (>>-)
-
-instance Foldable TAFResult where
-  foldr f z (TAFResultValue a) =
-    f a z
-  foldr _ z (ConnErrorResult _ ) =
-    z
-  foldr _ z ParseErrorResult =
-    z
-
-instance Traversable TAFResult where
-  traverse f (TAFResultValue a) =
-    TAFResultValue <$> f a
-  traverse _ (ConnErrorResult e) =
-    pure (ConnErrorResult e)
-  traverse _ ParseErrorResult =
-    pure ParseErrorResult
-
-instance Alt TAFResult where
-  TAFResultValue a <!> _ =
-    TAFResultValue a
-  ConnErrorResult _ <!> x =
-    x
-  ParseErrorResult <!> x =
-    x
-
-instance Extend TAFResult where
-  duplicated (TAFResultValue a) =
-    TAFResultValue (TAFResultValue a)
-  duplicated (ConnErrorResult e) =
-    ConnErrorResult e
-  duplicated ParseErrorResult =
-    ParseErrorResult
-
-instance Semigroup (TAFResult a) where
-  (<>) =
-    (<!>)
diff --git a/src/Data/Aviation/Metar/TAFResultT.hs b/src/Data/Aviation/Metar/TAFResultT.hs
deleted file mode 100644
--- a/src/Data/Aviation/Metar/TAFResultT.hs
+++ /dev/null
@@ -1,120 +0,0 @@
-{-# LANGUAGE NoImplicitPrelude #-}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE TypeFamilies #-}
-
-module Data.Aviation.Metar.TAFResultT where
-
-import Control.Applicative(Applicative(pure, (<*>)))
-import Control.Category((.))
-import Control.Monad(Monad(return, (>>=)), ap)
-import Data.Aviation.Metar.TAFResult(TAFResult(TAFResultValue, ConnErrorResult, ParseErrorResult))
-import Data.Eq(Eq((==)))
-import Data.Foldable(Foldable(foldr))
-import Data.Functor(Functor(fmap), (<$>))
-import Data.Functor.Alt(Alt((<!>)))
-import Data.Functor.Apply(Apply((<.>)))
-import Data.Functor.Bind(Bind((>>-)))
-import Data.Functor.Classes(Eq1, Show1, eq1, showsPrec1)
-import Data.Functor.Extend(Extend(duplicated))
-import Data.Ord((>))
-import Data.Semigroup(Semigroup((<>)))
-import Control.Lens hiding ((<.>))
-import Control.Monad.IO.Class(MonadIO(liftIO))
-import Control.Monad.Trans.Class(MonadTrans(lift))
-import Data.Eq.Deriving(deriveEq1)
-import Prelude(Show(showsPrec), showParen, showString)
-import Text.Show.Deriving(deriveShow1)
-
-newtype TAFResultT f a =
-  TAFResultT
-    (f (TAFResult a))
-
-makeClassy ''TAFResultT
-makeWrapped ''TAFResultT
-
-instance (Eq a, Eq1 f) => Eq (TAFResultT f a) where
-  TAFResultT x == TAFResultT y =
-    eq1 x y
-
-instance (Show a, Show1 f) => Show (TAFResultT f a) where
-  showsPrec n (TAFResultT x) =
-    showParen (n > 10) (showString "TafResultT " . showsPrec1 n x)
-
-deriveEq1 ''TAFResultT
-deriveShow1 ''TAFResultT
-
-instance Functor f => Functor (TAFResultT f) where
-  fmap f (TAFResultT x) =
-    TAFResultT (fmap (fmap f) x)
-
-instance Monad f => Apply (TAFResultT f) where
-  (<.>) =
-    ap
-
-instance Monad f => Applicative (TAFResultT f) where
-  pure =
-    TAFResultT . pure . pure
-  (<*>) =
-    ap
-
-instance Monad f => Bind (TAFResultT f) where
-  (>>-) =
-    (>>=)
-
-instance Monad f => Monad (TAFResultT f) where
-  return =
-    pure
-  TAFResultT x >>= f =
-    TAFResultT
-      (
-        x >>= \x' ->
-        case x' of
-          TAFResultValue x'' ->
-            let TAFResultT r = f x''
-            in  r
-          ConnErrorResult e ->
-            pure (ConnErrorResult e)
-          ParseErrorResult ->
-            pure ParseErrorResult
-      )
-
-instance Foldable f => Foldable (TAFResultT f) where
-  foldr f z (TAFResultT x) =
-    foldr (\a b -> foldr f b a) z x
-
-instance Traversable f => Traversable (TAFResultT f) where
-  traverse f (TAFResultT x) =
-    TAFResultT <$> traverse (traverse f) x
-
-instance Monad f => Alt (TAFResultT f) where
-  TAFResultT x <!> TAFResultT y =
-    TAFResultT
-      (
-        x >>= \x' ->
-        case x' of
-          TAFResultValue x'' ->
-            pure (TAFResultValue x'')
-          ConnErrorResult _ ->
-            y
-          ParseErrorResult ->
-            y
-      )
-
-instance Extend f => Extend (TAFResultT f) where
-  duplicated (TAFResultT x) =
-    TAFResultT (fmap (TAFResultValue . TAFResultT) (duplicated x))
-
-instance MonadIO f => MonadIO (TAFResultT f) where
-  liftIO =
-    TAFResultT . liftIO . fmap pure
-
-instance MonadTrans TAFResultT where
-  lift =
-    TAFResultT . fmap pure
-
-instance Monad f => Semigroup (TAFResultT f a) where
-  (<>) =
-    (<!>)