Modernize

Author: nikita-volkov

.github/workflows/format-and-test.yaml

@@ -31,7 +31,12 @@ jobs:
       ghc: "8.8.1"
       skip-doctest: true
       skip-benchmarks: true
+      test-options: >
+        --quickcheck-tests 10_000
   
   build-with-latest:
     uses: nikita-volkov/haskell-hackage-lib-github-actions-workflows/.github/workflows/build.yaml@v4
     secrets: inherit
+    with:
+      test-options: >
+        --quickcheck-tests 10_000

iri.cabal

@@ -21,12 +21,11 @@ source-repository head
   type: git
   location: https://github.com/nikita-volkov/iri
 
-library
-  hs-source-dirs: library
+common base
   default-language: Haskell2010
   default-extensions:
-    Arrows
     BangPatterns
+    BlockArguments
     ConstraintKinds
     DataKinds
     DefaultSignatures
@@ -35,35 +34,56 @@ library
     DeriveFunctor
     DeriveGeneric
     DeriveTraversable
+    DerivingStrategies
     EmptyDataDecls
     FlexibleContexts
     FlexibleInstances
     FunctionalDependencies
     GADTs
     GeneralizedNewtypeDeriving
-    ImportQualifiedPost
     LambdaCase
     LiberalTypeSynonyms
     MagicHash
     MultiParamTypeClasses
     MultiWayIf
     NoImplicitPrelude
     NoMonomorphismRestriction
+    NumericUnderscores
     OverloadedStrings
     ParallelListComp
     PatternGuards
-    PatternSynonyms
     QuasiQuotes
     RankNTypes
     RecordWildCards
     ScopedTypeVariables
     StandaloneDeriving
+    StrictData
     TemplateHaskell
     TupleSections
+    TypeApplications
     TypeFamilies
     TypeOperators
     UnboxedTuples
+    ViewPatterns
+
+common executable
+  import: base
+  ghc-options:
+    -O2
+    -threaded
+    -with-rtsopts=-N
+    -rtsopts
+    -funbox-strict-fields
 
+common test
+  import: base
+  ghc-options:
+    -threaded
+    -with-rtsopts=-N
+
+library
+  import: base
+  hs-source-dirs: library
   exposed-modules:
     Iri.Data
     Iri.Optics
@@ -112,7 +132,7 @@ library
     ptr >=0.16.1 && <0.17,
     template-haskell >=2.17 && <3,
     text >=2 && <3,
-    text-builder >=0.6.7.2 && <0.7,
+    text-builder ^>=1,
     th-lift >=0.8 && <0.9,
     th-lift-instances >=0.1.20 && <0.2,
     unordered-containers >=0.2 && <0.3,
@@ -138,50 +158,10 @@ library punycode
     Data.Text.Punycode.Shared
 
 test-suite test
+  import: test
   type: exitcode-stdio-1.0
   hs-source-dirs: test
   main-is: Main.hs
-  default-language: Haskell2010
-  default-extensions:
-    Arrows
-    BangPatterns
-    ConstraintKinds
-    DataKinds
-    DefaultSignatures
-    DeriveDataTypeable
-    DeriveFoldable
-    DeriveFunctor
-    DeriveGeneric
-    DeriveTraversable
-    EmptyDataDecls
-    FlexibleContexts
-    FlexibleInstances
-    FunctionalDependencies
-    GADTs
-    GeneralizedNewtypeDeriving
-    ImportQualifiedPost
-    LambdaCase
-    LiberalTypeSynonyms
-    MagicHash
-    MultiParamTypeClasses
-    MultiWayIf
-    NoImplicitPrelude
-    NoMonomorphismRestriction
-    OverloadedStrings
-    ParallelListComp
-    PatternGuards
-    PatternSynonyms
-    QuasiQuotes
-    RankNTypes
-    RecordWildCards
-    ScopedTypeVariables
-    StandaloneDeriving
-    TemplateHaskell
-    TupleSections
-    TypeFamilies
-    TypeOperators
-    UnboxedTuples
-
   build-depends:
     iri,
     rerebase <2,

library/Iri/CodePointPredicates/Core.hs

@@ -1,6 +1,6 @@
 module Iri.CodePointPredicates.Core where
 
-import Data.Vector.Unboxed qualified as A
+import qualified Data.Vector.Unboxed as A
 import Iri.Prelude hiding (Predicate, inRange, (&&&), (|||))
 
 type Predicate =

library/Iri/CodePointPredicates/Rfc3987.hs

@@ -114,7 +114,7 @@
 module Iri.CodePointPredicates.Rfc3987 where
 
 import Iri.CodePointPredicates.Core
-import Iri.CodePointPredicates.Rfc3986 qualified as A
+import qualified Iri.CodePointPredicates.Rfc3986 as A
 import Iri.Prelude hiding (Predicate, inRange, (&&&), (|||))
 
 scheme :: Predicate

library/Iri/Data/Functions.hs

@@ -14,7 +14,7 @@ httpIriFromIri (Iri (Scheme scheme) hierarchy query fragment) =
     case hierarchy of
       AuthorisedHierarchy (Authority userInfo host port) path -> case userInfo of
         MissingUserInfo -> Right (HttpIri security host port path query fragment)
-        PresentUserInfo (User user) _ -> Left ("User Info is present")
+        PresentUserInfo (User _) _ -> Left ("User Info is present")
       _ -> Left ("Not an authorised hierarchy")
 
 -- | Generalize an HTTP IRI to IRI

library/Iri/Data/Instances/Lift.hs

@@ -2,12 +2,12 @@
 
 module Iri.Data.Instances.Lift where
 
-import Data.WideWord.Word128 qualified
+import qualified Data.WideWord.Word128
 import Iri.Data.Types
 import Iri.Prelude
 import Language.Haskell.TH.Lift
 import Language.Haskell.TH.Syntax
-import Net.IPv6 qualified
+import qualified Net.IPv6
 
 fmap concat
   $ traverse deriveLift

library/Iri/Data/Instances/Show.hs

@@ -2,10 +2,10 @@
 
 module Iri.Data.Instances.Show where
 
-import Data.Text qualified as B
+import qualified Data.Text as B
 import Iri.Data.Types
 import Iri.Prelude
-import Iri.Rendering.Text.Internal qualified as A
+import qualified Iri.Rendering.Text.Internal as A
 
 instance Show Iri where
   show =

library/Iri/MonadPlus.hs

@@ -1,8 +1,8 @@
 module Iri.MonadPlus where
 
 import Iri.Prelude hiding (foldl)
-import Ptr.ByteString qualified as ByteString
-import Ptr.Poking qualified as Poking
+import qualified Ptr.ByteString as ByteString
+import qualified Ptr.Poking as Poking
 
 {-# INLINE foldl #-}
 foldl :: (MonadPlus m) => (a -> b -> a) -> a -> m b -> m a

library/Iri/Optics/Defs.hs

@@ -1,13 +1,13 @@
 module Iri.Optics.Defs where
 
-import Data.Text.Encoding qualified as Text
+import qualified Data.Text.Encoding as Text
 import Iri.Data
 import Iri.Optics.Basics
-import Iri.Parsing.ByteString qualified as B
-import Iri.Parsing.Text qualified as D
+import qualified Iri.Parsing.ByteString as B
+import qualified Iri.Parsing.Text as D
 import Iri.Prelude
-import Iri.Rendering.ByteString qualified as A
-import Iri.Rendering.Text qualified as C
+import qualified Iri.Rendering.ByteString as A
+import qualified Iri.Rendering.Text as C
 
 -- * Definitions by source
 

library/Iri/Parsing/Attoparsec/ByteString.hs

@@ -8,21 +8,21 @@ module Iri.Parsing.Attoparsec.ByteString
 where
 
 import Data.Attoparsec.ByteString hiding (try)
-import Data.Attoparsec.ByteString.Char8 qualified as F
-import Data.ByteString qualified as K
-import Data.Text.Encoding qualified as B
-import Data.Text.Encoding.Error qualified as L
-import Data.Text.Punycode qualified as A
-import Data.Vector qualified as S
-import Iri.CodePointPredicates.Rfc3986 qualified as C
+import qualified Data.Attoparsec.ByteString.Char8 as F
+import qualified Data.ByteString as K
+import qualified Data.Text.Encoding as B
+import qualified Data.Text.Encoding.Error as L
+import qualified Data.Text.Punycode as A
+import qualified Data.Vector as S
+import qualified Iri.CodePointPredicates.Rfc3986 as C
 import Iri.Data
-import Iri.MonadPlus qualified as R
-import Iri.PercentEncoding qualified as I
+import qualified Iri.MonadPlus as R
+import qualified Iri.PercentEncoding as I
 import Iri.Prelude hiding (foldl, hash)
-import Net.IPv4 qualified as M
-import Net.IPv6 qualified as N
-import Text.Builder qualified as J
-import VectorBuilder.MonadPlus qualified as E
+import qualified Net.IPv4 as M
+import qualified Net.IPv6 as N
+import qualified TextBuilder as J
+import qualified VectorBuilder.MonadPlus as E
 
 {-# INLINE percent #-}
 percent :: Parser Word8
@@ -87,7 +87,7 @@ uri :: Parser Iri
 uri =
   labeled "URI" $ do
     parsedScheme <- scheme
-    colon
+    _ <- colon
     parsedHierarchy <- hierarchy
     parsedQuery <- query
     parsedFragment <- fragment
@@ -99,12 +99,12 @@ uri =
 httpUri :: Parser HttpIri
 httpUri =
   labeled "HTTP URI" $ do
-    satisfy (\x -> x == 104 || x == 72)
-    satisfy (\x -> x == 116 || x == 84)
-    satisfy (\x -> x == 116 || x == 84)
-    satisfy (\x -> x == 112 || x == 80)
+    _ <- satisfy (\x -> x == 104 || x == 72)
+    _ <- satisfy (\x -> x == 116 || x == 84)
+    _ <- satisfy (\x -> x == 116 || x == 84)
+    _ <- satisfy (\x -> x == 112 || x == 80)
     secure <- satisfy (\b -> b == 115 || b == 83) $> True <|> pure False
-    string "://"
+    _ <- string "://"
     parsedHost <- host
     parsedPort <- PresentPort <$> (colon *> port) <|> pure MissingPort
     parsedPath <- (forwardSlash *> path) <|> pure (Path mempty)
@@ -169,26 +169,26 @@ ipV6 :: Parser IPv6
 ipV6 =
   do
     a <- F.hexadecimal
-    colon
+    _ <- colon
     b <- F.hexadecimal
-    colon
+    _ <- colon
     c <- F.hexadecimal
-    colon
+    _ <- colon
     d <- F.hexadecimal
-    colon
+    _ <- colon
     mplus
       ( do
           e <- F.hexadecimal
-          colon
+          _ <- colon
           f <- F.hexadecimal
-          colon
+          _ <- colon
           g <- F.hexadecimal
-          colon
+          _ <- colon
           h <- F.hexadecimal
           return (N.fromWord16s a b c d e f g h)
       )
       ( do
-          colon
+          _ <- colon
           return (N.fromWord16s a b c d 0 0 0 0)
       )
 
@@ -252,7 +252,7 @@ utf8Chunks chunk =
           fail "Unexpected decoding error"
     finish (builder, undecodedBytes, _) =
       if K.null undecodedBytes
-        then return (J.run builder)
+        then return (J.toText builder)
         else fail (showString "UTF8 decoding: Bytes remaining: " (show undecodedBytes))
 
 {-# INLINEABLE urlEncodedString #-}
@@ -270,7 +270,7 @@ urlEncodedString unencodedBytesPredicate =
 percentEncodedByte :: Parser Word8
 percentEncodedByte =
   labeled "Percent-encoded byte" $ do
-    percent
+    _ <- percent
     byte1 <- anyWord8
     byte2 <- anyWord8
     I.matchPercentEncodedBytes (fail "Broken percent encoding") return byte1 byte2