Move some type definitions back into the public API.

Since none of the internal code still relies on these type definitions, remove
the `D.L.I.Normal` and `D.L.I.Monoidal` modules, and move the types to the
`D.L.Normal` and `D.L.Monoidal` modules.

Author: jorisdral

lsm-tree.cabal

@@ -135,8 +135,6 @@ library
     Database.LSMTree.Internal.Lookup
     Database.LSMTree.Internal.Merge
     Database.LSMTree.Internal.MergeSchedule
-    Database.LSMTree.Internal.Monoidal
-    Database.LSMTree.Internal.Normal
     Database.LSMTree.Internal.PageAcc
     Database.LSMTree.Internal.PageAcc1
     Database.LSMTree.Internal.Paths

src/Database/LSMTree/Internal/Monoidal.hs

@@ -135,7 +135,6 @@ import           Database.LSMTree.Common (IOLike, Range (..), SerialiseKey,
 import qualified Database.LSMTree.Common as Common
 import qualified Database.LSMTree.Internal as Internal
 import qualified Database.LSMTree.Internal.Entry as Entry
-import           Database.LSMTree.Internal.Monoidal
 import           Database.LSMTree.Internal.RawBytes (RawBytes)
 import qualified Database.LSMTree.Internal.Serialise as Internal
 import qualified Database.LSMTree.Internal.Vector as V
@@ -216,6 +215,12 @@ close (Internal.MonoidalTable th) = Internal.close th
   Table queries
 -------------------------------------------------------------------------------}
 
+-- | Result of a single point lookup.
+data LookupResult v =
+    NotFound
+  | Found !v
+  deriving stock (Eq, Show, Functor, Foldable, Traversable)
+
 {-# SPECIALISE lookups ::
      (SerialiseKey k, SerialiseValue v, ResolveValue v)
   => V.Vector k
@@ -244,6 +249,11 @@ lookups ks (Internal.MonoidalTable th) =
       Entry.Delete             -> NotFound
     toLookupResult Nothing = NotFound
 
+-- | A result for one point in a cursor read or range query.
+data QueryResult k v =
+    FoundInQuery !k !v
+  deriving stock (Eq, Show, Functor, Foldable, Traversable)
+
 {-# SPECIALISE rangeLookup ::
      (SerialiseKey k, SerialiseValue v, ResolveValue v)
   => Range k
@@ -397,6 +407,22 @@ readCursor n (Internal.MonoidalCursor c) =
   Table updates
 -------------------------------------------------------------------------------}
 
+-- | Monoidal tables support insert, delete and monoidal upsert operations.
+--
+-- An __update__ is a term that groups all types of table-manipulating
+-- operations, like inserts, deletes and mupserts.
+data Update v =
+    Insert !v
+  | Delete
+    -- | TODO: should be given a more suitable name.
+  | Mupsert !v
+  deriving stock (Show, Eq)
+
+instance NFData v => NFData (Update v) where
+  rnf (Insert v)  = rnf v
+  rnf Delete      = ()
+  rnf (Mupsert v) = rnf v
+
 {-# SPECIALISE updates ::
      (SerialiseKey k, SerialiseValue v, ResolveValue v)
   => V.Vector (k, Update v)

src/Database/LSMTree/Internal/Normal.hs

@@ -111,6 +111,7 @@ module Database.LSMTree.Normal (
   , IOLike
   ) where
 
+import           Control.DeepSeq
 import           Control.Exception (throw)
 import           Control.Monad
 import           Data.Bifunctor (Bifunctor (..))
@@ -125,7 +126,6 @@ import qualified Database.LSMTree.Common as Common
 import qualified Database.LSMTree.Internal as Internal
 import qualified Database.LSMTree.Internal.BlobRef as Internal
 import qualified Database.LSMTree.Internal.Entry as Entry
-import           Database.LSMTree.Internal.Normal
 import qualified Database.LSMTree.Internal.Serialise as Internal
 import qualified Database.LSMTree.Internal.Vector as V
 import qualified System.FS.API as FS
@@ -290,6 +290,24 @@ close (Internal.NormalTable th) = Internal.close th
   Table queries
 -------------------------------------------------------------------------------}
 
+-- | Result of a single point lookup.
+data LookupResult v blobref =
+    NotFound
+  | Found         !v
+  | FoundWithBlob !v !blobref
+  deriving stock (Eq, Show, Functor, Foldable, Traversable)
+
+instance Bifunctor LookupResult where
+  first f = \case
+      NotFound          -> NotFound
+      Found v           -> Found (f v)
+      FoundWithBlob v b -> FoundWithBlob (f v) b
+
+  second g = \case
+      NotFound          -> NotFound
+      Found v           -> Found v
+      FoundWithBlob v b -> FoundWithBlob v (g b)
+
 {-# SPECIALISE lookups ::
      (SerialiseKey k, SerialiseValue v)
   => V.Vector k
@@ -319,6 +337,17 @@ lookups ks (Internal.NormalTable th) =
       Entry.Delete              -> NotFound
     toLookupResult Nothing = NotFound
 
+-- | A result for one point in a cursor read or range lookup.
+data QueryResult k v blobref =
+    FoundInQuery         !k !v
+  | FoundInQueryWithBlob !k !v !blobref
+  deriving stock (Eq, Show, Functor, Foldable, Traversable)
+
+instance Bifunctor (QueryResult k) where
+  bimap f g = \case
+      FoundInQuery k v           -> FoundInQuery k (f v)
+      FoundInQueryWithBlob k v b -> FoundInQueryWithBlob k (f v) (g b)
+
 {-# SPECIALISE rangeLookup ::
      (SerialiseKey k, SerialiseValue v)
   => Range k
@@ -488,6 +517,19 @@ toNormalQueryResult k v = \case
   Table updates
 -------------------------------------------------------------------------------}
 
+-- | Normal tables support insert and delete operations.
+--
+-- An __update__ is a term that groups all types of table-manipulating
+-- operations, like inserts and deletes.
+data Update v blob =
+    Insert !v !(Maybe blob)
+  | Delete
+  deriving stock (Show, Eq)
+
+instance (NFData v, NFData blob) => NFData (Update v blob) where
+  rnf Delete       = ()
+  rnf (Insert v b) = rnf v `seq` rnf b
+
 {-# SPECIALISE updates ::
      (SerialiseKey k, SerialiseValue v, SerialiseValue blob)
   => V.Vector (k, Update v blob)

src/Database/LSMTree/Monoidal.hs

@@ -12,8 +12,8 @@ import           Data.Semigroup
 import           Database.LSMTree.Extras.Generators ()
 import           Database.LSMTree.Internal.BlobRef
 import           Database.LSMTree.Internal.Entry
-import qualified Database.LSMTree.Internal.Monoidal as Monoidal
-import qualified Database.LSMTree.Internal.Normal as Normal
+import qualified Database.LSMTree.Monoidal as Monoidal
+import qualified Database.LSMTree.Normal as Normal
 import           Test.QuickCheck
 import           Test.QuickCheck.Classes (semigroupLaws)
 import           Test.Tasty