Fix some warnings

benchmarks/haskell/Benchmarks/FileWrite.hs

@@ -15,11 +15,10 @@ module Benchmarks.FileWrite
 import Control.DeepSeq (NFData, deepseq)
 import Data.Bifunctor (first)
 import Data.List (intercalate, intersperse)
-import Data.Semigroup ((<>))
 import Data.String (fromString)
 import Data.Text (StrictText)
 import Data.Text.Internal.Lazy (LazyText, defaultChunkSize)
-import System.IO (Handle, Newline(CRLF,LF), NewlineMode(NewlineMode), BufferMode(NoBuffering,LineBuffering,BlockBuffering), hSetBuffering, hSetNewlineMode)
+import System.IO (Handle, Newline(CRLF,LF), NewlineMode(NewlineMode), BufferMode(..), hSetBuffering, hSetNewlineMode)
 import Test.Tasty.Bench (Benchmark, bgroup, bench, whnfAppIO)
 import qualified Data.Text as T
 import qualified Data.Text.IO as T
@@ -112,11 +111,15 @@ mkFileWriteBenchmarks mkSinkNRemove = do
 #endif
 
   where
-  lazy, lazyNewlines, lazySmallChunks, lazySmallChunksNewlines :: (String, StrictText -> LazyText)
+  lazy, lazyNewlines :: (String, StrictText -> LazyText)
   lazy                    = ("lazy",                            L.fromChunks . T.chunksOf defaultChunkSize)
   lazyNewlines            = ("lazy many newlines",              snd lazy . snd strictNewlines)
+
+#ifdef ExtendedBenchmarks
+  lazySmallChunks, lazySmallChunksNewlines :: (String, StrictText -> LazyText)
   lazySmallChunks         = ("lazy small chunks",               L.fromChunks . T.chunksOf 10)
   lazySmallChunksNewlines = ("lazy small chunks many newlines", snd lazySmallChunks . snd strictNewlines)
+#endif
 
   strict, strictNewlines :: (String, StrictText -> StrictText)
   strict                  = ("strict",                          id)

benchmarks/haskell/Benchmarks/Micro.hs

@@ -2,14 +2,15 @@
 
 module Benchmarks.Micro (benchmark) where
 
+import qualified Data.List.NonEmpty as NE
 import qualified Data.Text.Lazy as TL
 import qualified Data.Text as T
 import Test.Tasty.Bench (Benchmark, Benchmarkable, bgroup, bcompareWithin, bench, nf)
 
 benchmark :: Benchmark
 benchmark = bgroup "Micro"
   [ blinear "lazy-inits--last" 500000 2 0.1 $ \len ->
-      nf (last . TL.inits) (chunks len)
+      nf (NE.last . TL.initsNE) (chunks len)
   , blinear "lazy-inits--map-take1" 500000 2 0.1 $ \len ->
       nf (map (TL.take 1) . TL.inits) (chunks len)
   ]

benchmarks/haskell/Benchmarks/Programs/Fold.hs

@@ -17,8 +17,9 @@ module Benchmarks.Programs.Fold
     ( benchmark
     ) where
 
-import Data.List (foldl')
+import Data.Foldable (Foldable(..))
 import Data.List (intersperse)
+import Prelude hiding (Foldable(..))
 import System.IO (Handle)
 import Test.Tasty.Bench (Benchmark, bench, whnfIO)
 import qualified Data.Text as T
@@ -29,16 +30,16 @@ import qualified Data.Text.Lazy.IO as TL
 
 benchmark :: FilePath -> Handle -> Benchmark
 benchmark i o =
-    bench "Fold" $ whnfIO $ T.readFile i >>= TL.hPutStr o . fold 80
+    bench "Fold" $ whnfIO $ T.readFile i >>= TL.hPutStr o . foldText 80
 
 -- | We represent a paragraph by a word list
 --
 type Paragraph = [T.Text]
 
 -- | Fold a text
 --
-fold :: Int -> T.Text -> TL.Text
-fold maxWidth = TLB.toLazyText . mconcat .
+foldText :: Int -> T.Text -> TL.Text
+foldText maxWidth = TLB.toLazyText . mconcat .
     intersperse "\n\n" . map (foldParagraph maxWidth) . paragraphs
 
 -- | Fold a paragraph

benchmarks/haskell/Benchmarks/ReadNumbers.hs

@@ -21,8 +21,9 @@ module Benchmarks.ReadNumbers
     , benchmark
     ) where
 
+import Data.Foldable (Foldable(..))
+import Prelude hiding (Foldable(..))
 import Test.Tasty.Bench (Benchmark, bgroup, bench, whnf)
-import Data.List (foldl')
 import qualified Data.Text as T
 import qualified Data.Text.IO as T
 import qualified Data.Text.Lazy as TL

benchmarks/haskell/Benchmarks/WordFrequencies.hs

@@ -13,9 +13,10 @@ module Benchmarks.WordFrequencies
     , benchmark
     ) where
 
-import Test.Tasty.Bench (Benchmark, bench, bgroup, whnf)
-import Data.List (foldl')
+import Data.Foldable (Foldable(..))
 import Data.Map (Map)
+import Prelude hiding (Foldable(..))
+import Test.Tasty.Bench (Benchmark, bench, bgroup, whnf)
 import qualified Data.Map as M
 import qualified Data.Text as T
 import qualified Data.Text.IO as T

src/Data/Text/Encoding/Error.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, DeriveDataTypeable #-}
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE Safe #-}
 -- |
 -- Module      : Data.Text.Encoding.Error
@@ -36,7 +36,6 @@ module Data.Text.Encoding.Error
 
 import Control.DeepSeq (NFData (..))
 import Control.Exception (Exception, throw)
-import Data.Typeable (Typeable)
 import Data.Word (Word8)
 import Numeric (showHex)
 
@@ -74,7 +73,7 @@ data UnicodeException =
   | EncodeError String (Maybe Char)
     -- ^ Tried to encode a character that could not be represented
     -- under the given encoding, or ran out of input in mid-encode.
-    deriving (Eq, Typeable)
+    deriving (Eq)
 
 {-# DEPRECATED EncodeError "This constructor is never used, and will be removed." #-}
 

src/Data/Text/Internal.hs

@@ -1,6 +1,5 @@
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE UnboxedTuples #-}
 {-# OPTIONS_HADDOCK not-home #-}
@@ -58,15 +57,13 @@ import Control.Monad.ST (ST, runST)
 import Data.Bits
 import Data.Int (Int32, Int64)
 import Data.Text.Internal.Unsafe.Char (ord, unsafeWrite)
-import Data.Typeable (Typeable)
 import qualified Data.Text.Array as A
 
 -- | A space efficient, packed, unboxed Unicode text type.
 data Text = Text
     {-# UNPACK #-} !A.Array -- ^ bytearray encoded as UTF-8
     {-# UNPACK #-} !Int     -- ^ offset in bytes (not in Char!), pointing to a start of UTF-8 sequence
     {-# UNPACK #-} !Int     -- ^ length in bytes (not in Char!), pointing to an end of UTF-8 sequence
-    deriving (Typeable)
 
 -- | Type synonym for the strict flavour of 'Text'.
 type StrictText = Text

src/Data/Text/Internal/Lazy.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE BangPatterns, DeriveDataTypeable #-}
+{-# LANGUAGE BangPatterns #-}
 {-# OPTIONS_HADDOCK not-home #-}
 
 -- |
@@ -43,7 +43,6 @@ module Data.Text.Internal.Lazy
 
 import Data.Bits (shiftL)
 import Data.Text ()
-import Data.Typeable (Typeable)
 import Foreign.Storable (sizeOf)
 import qualified Data.Text.Array as A
 import qualified Data.Text.Internal as T
@@ -55,7 +54,6 @@ data Text = Empty
           -- @since 2.1.2
           | Chunk {-# UNPACK #-} !T.Text Text
           -- ^ Chunks must be non-empty, this invariant is not checked.
-            deriving (Typeable)
 
 -- | Type synonym for the lazy flavour of 'Text'.
 type LazyText = Text

src/Data/Text/Lazy/Builder/RealFloat.hs

@@ -1,6 +1,9 @@
 {-# LANGUAGE CPP, OverloadedStrings #-}
 {-# LANGUAGE Trustworthy #-}
 
+{-# OPTIONS_GHC -Wno-unrecognised-warning-flags #-}
+{-# OPTIONS_GHC -Wno-x-partial #-}
+
 -- |
 -- Module:    Data.Text.Lazy.Builder.RealFloat
 -- Copyright: (c) The University of Glasgow 1994-2002

src/Data/Text/Lazy/Internal.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE BangPatterns, DeriveDataTypeable #-}
 -- |
 -- Module      : Data.Text.Lazy.Internal
 -- Copyright   : (c) 2013 Bryan O'Sullivan

tests/Tests/Properties/Substrings.hs

@@ -229,9 +229,8 @@ split p xs = loop xs
       (l, []) -> [l]
       (l, _ : s') -> l : loop s'
 
-t_chunksOf_same_lengths k = conjoin . map ((===k) . T.length) . ini . T.chunksOf k
-  where ini [] = []
-        ini xs = init xs
+t_chunksOf_same_lengths k =
+  conjoin . map ((===k) . T.length) . drop 1 . reverse . T.chunksOf k
 
 t_chunksOf_length k t = len === T.length t .||. property (k <= 0 && len == 0)
   where len = L.sum . L.map T.length $ T.chunksOf k t

tests/Tests/Properties/Transcoding.hs

@@ -1,7 +1,10 @@
 -- | Tests for encoding and decoding
 
 {-# LANGUAGE CPP, OverloadedStrings, ScopedTypeVariables #-}
-{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
+{-# OPTIONS_GHC -Wno-missing-signatures #-}
+{-# OPTIONS_GHC -Wno-unrecognised-warning-flags #-}
+{-# OPTIONS_GHC -Wno-x-partial #-}
+
 module Tests.Properties.Transcoding
     ( testTranscoding
     ) where