Fix by HLint

ff-notes · Mar 7, 2020 · ea4420a · ea4420a
1 parent 31da00b
commit ea4420a
Show file tree

Hide file tree

Showing 3 changed files with 72 additions and 113 deletions.
diff --git a/ron-rdt/lib/RON/Data/RGA.hs b/ron-rdt/lib/RON/Data/RGA.hs
@@ -35,49 +35,35 @@ module RON.Data.RGA
   )
 where
 
-import Data.Algorithm.Diff (Diff (Both, First, Second), getGroupedDiffBy)
+import           Data.Algorithm.Diff (Diff (Both, First, Second),
+                                      getGroupedDiffBy)
+import           Data.Bifunctor (second)
 import qualified Data.HashMap.Strict as HashMap
-import Data.Map.Strict ((!?))
+import           Data.Map.Strict ((!?))
 import qualified Data.Map.Strict as Map
 import qualified Data.Text as Text
-import RON.Data.Internal
-  ( MonadObjectState,
-    ReducedChunk (ReducedChunk, rcBody, rcRef),
-    Reducible,
-    Rep,
-    Replicated (encoding),
-    ReplicatedAsObject,
-    ReplicatedAsPayload,
-    Unapplied,
-    applyPatches,
-    fromRon,
-    getObjectStateChunk,
-    modifyObjectStateChunk_,
-    newObject,
-    newRon,
-    objectEncoding,
-    readObject,
-    reduceUnappliedPatches,
-    reducibleOpType,
-    stateFromChunk,
-    stateToChunk,
-    toPayload,
-  )
-import RON.Error (MonadE, errorContext, throwErrorText)
-import RON.Event (ReplicaClock, getEventUuid, getEventUuids)
-import RON.Prelude
-import RON.Semilattice (Semilattice)
-import RON.Types
-  ( ObjectRef (ObjectRef),
-    Op (Op, opId, payload, refId),
-    StateChunk (StateChunk),
-    StateFrame,
-    UUID,
-    WireStateChunk (WireStateChunk, stateBody, stateType),
-  )
-import RON.UUID (uuidVersion, pattern Zero)
+
+import           RON.Data.Internal (MonadObjectState,
+                                    ReducedChunk (ReducedChunk, rcBody, rcRef),
+                                    Reducible, Rep, Replicated (encoding),
+                                    ReplicatedAsObject, ReplicatedAsPayload,
+                                    Unapplied, applyPatches, fromRon,
+                                    getObjectStateChunk,
+                                    modifyObjectStateChunk_, newObject, newRon,
+                                    objectEncoding, readObject,
+                                    reduceUnappliedPatches, reducibleOpType,
+                                    stateFromChunk, stateToChunk, toPayload)
+import           RON.Error (MonadE, errorContext, throwErrorText)
+import           RON.Event (ReplicaClock, getEventUuid, getEventUuids)
+import           RON.Prelude
+import           RON.Semilattice (Semilattice)
+import           RON.Types (ObjectRef (ObjectRef),
+                            Op (Op, opId, payload, refId),
+                            StateChunk (StateChunk), StateFrame, UUID,
+                            WireStateChunk (WireStateChunk, stateBody, stateType))
+import           RON.Util.Word (pattern B11, ls60)
+import           RON.UUID (pattern Zero, uuidVersion)
 import qualified RON.UUID as UUID
-import RON.Util.Word (ls60, pattern B11)
 
 {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
 
@@ -201,7 +187,7 @@ instance Reducible RgaRep where
   stateToChunk (RgaRep rga) = maybe [] vertexListToOps rga
 
   applyPatches rga (patches, ops) =
-    bimap id patchSetToChunks . reapplyPatchSetToState rga
+    second patchSetToChunks . reapplyPatchSetToState rga
       $ foldMap patchSetFromChunk patches <> foldMap patchSetFromRawOp ops
 
   reduceUnappliedPatches (patches, ops) =

diff --git a/ron-storage/lib/RON/Storage/FS.hs b/ron-storage/lib/RON/Storage/FS.hs
@@ -34,59 +34,37 @@ module RON.Storage.FS
   )
 where
 
-import Control.Concurrent.STM
-  ( TChan,
-    atomically,
-    dupTChan,
-    newBroadcastTChanIO,
-    writeTChan,
-  )
-import Data.Bits (shiftL)
+import           RON.Prelude
+
+import           Control.Concurrent.STM (TChan, atomically, dupTChan,
+                                         newBroadcastTChanIO, writeTChan)
+import           Data.Bits (shiftL)
 import qualified Data.ByteString.Lazy as BSL
-import Data.Maybe (isJust)
-import Network.Info (MAC (MAC), getNetworkInterfaces, mac)
-import RON.Epoch (EpochClock, getCurrentEpochTime, runEpochClock)
-import RON.Error (Error, throwErrorString)
-import RON.Event
-  ( EpochTime,
-    ReplicaClock,
-    ReplicaId,
-    advance,
-    applicationSpecific,
-    getEvents,
-    getPid,
-  )
-import RON.Prelude
-import RON.Storage as X
-import RON.Storage.Backend
-  ( DocId (DocId),
-    MonadStorage,
-    RawDocId,
-    changeDocId,
-    deleteVersion,
-    getCollections,
-    getDocumentVersions,
-    getDocuments,
-    loadVersionContent,
-    saveVersionContent,
-  )
-import System.Directory
-  ( canonicalizePath,
-    createDirectoryIfMissing,
-    doesDirectoryExist,
-    doesPathExist,
-    listDirectory,
-    makeAbsolute,
-    removeFile,
-    renameDirectory,
-  )
+import           Data.Foldable (find)
+import           Data.Maybe (isJust)
+import           Network.Info (MAC (MAC), getNetworkInterfaces, mac)
+import           System.Directory (canonicalizePath, createDirectoryIfMissing,
+                                   doesDirectoryExist, doesPathExist,
+                                   listDirectory, makeAbsolute, removeFile,
+                                   renameDirectory)
+import           System.FilePath (makeRelative, splitDirectories, (</>))
+import           System.FSNotify (StopListening)
 import qualified System.FSNotify as FSNotify
-import System.FSNotify (StopListening)
-import System.FilePath ((</>), makeRelative, splitDirectories)
-import System.IO (hPutStrLn, stderr)
-import System.IO.Error (isDoesNotExistError)
-import System.Random.TF (newTFGen)
-import System.Random.TF.Instances (random)
+import           System.IO (hPutStrLn, stderr)
+import           System.IO.Error (isDoesNotExistError)
+import           System.Random.TF (newTFGen)
+import           System.Random.TF.Instances (random)
+
+import           RON.Epoch (EpochClock, getCurrentEpochTime, runEpochClock)
+import           RON.Error (Error, throwErrorString)
+import           RON.Event (EpochTime, ReplicaClock, ReplicaId, advance,
+                            applicationSpecific, getEvents, getPid)
+import           RON.Storage as X
+import           RON.Storage.Backend (DocId (DocId), MonadStorage, RawDocId,
+                                      changeDocId, deleteVersion,
+                                      getCollections, getDocumentVersions,
+                                      getDocuments, loadVersionContent,
+                                      saveVersionContent)
 
 -- | Environment is the dataDir
 newtype Storage a = Storage (ExceptT Error (ReaderT Handle EpochClock) a)
@@ -229,8 +207,7 @@ getMacAddress = do
   macAddress <- getMac
   pure $ decodeMac <$> macAddress
   where
-    getMac =
-      listToMaybe . filter (/= minBound) . map mac <$> getNetworkInterfaces
+    getMac = find (/= minBound) . map mac <$> getNetworkInterfaces
     decodeMac (MAC b5 b4 b3 b2 b1 b0) =
       (fromIntegral b5 `shiftL` 40)
         + (fromIntegral b4 `shiftL` 32)

diff --git a/ron/lib/RON/Text/Serialize/UUID.hs b/ron/lib/RON/Text/Serialize/UUID.hs
@@ -43,18 +43,11 @@ serializeUuidKey
     -> ByteStringL
 serializeUuidKey prevKey prev this =
     BSL.fromStrict $ case uuidVariant thisFields of
-        B00 -> minimumByLength
-            $   unzipped thisFields
-            :   [ z
-                | uuidVariant (split prevKey) == B00
-                , Just z <- [zipUuid (split prevKey) thisFields]
-                ]
-            ++  [ "`" <> z
-                | prev /= zero
-                , uuidVariant (split prev) == B00
-                , Just z <- [zipUuid (split prev) thisFields]
-                ]
-        _   -> serializeUuidGeneric this
+        B00 -> minimumByLength $
+                unzipped thisFields
+            :   zipIfDefaultVariant prevKey this
+            ++  ["`" <> z | prev /= zero, z <- zipIfDefaultVariant prev this]
+        _ -> serializeUuidGeneric this
   where
     thisFields = split this
 
@@ -65,17 +58,20 @@ serializeUuidAtom
     -> ByteStringL
 serializeUuidAtom prev this =
     BSL.fromStrict $ case uuidVariant thisFields of
-        B00 -> minimumByLength
-            $   unzipped thisFields
-            :   [ z
-                | prev /= zero
-                , uuidVariant (split prev) == B00
-                , Just z <- [zipUuid (split prev) thisFields]
-                ]
-        _   -> serializeUuidGeneric this
+        B00 -> minimumByLength $
+                unzipped thisFields
+            :   (guard (prev /= zero) *> zipIfDefaultVariant prev this)
+        _ -> serializeUuidGeneric this
   where
     thisFields = split this
 
+zipIfDefaultVariant :: UUID -> UUID -> [ByteString]
+zipIfDefaultVariant prev this =
+    [ z
+    | uuidVariant (split prev) == B00
+    , Just z <- [zipUuid (split prev) (split this)]
+    ]
+
 unzipped :: UuidFields -> ByteString
 unzipped UuidFields{..} = x' <> y'
   where