{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# OPTIONS_HADDOCK prune not-home #-}

{- |
Copyright   : (c) 2018-2022 Tim Emiola
SPDX-License-Identifier: BSD3
Maintainer  : Tim Emiola <tim@emio.la>

Provides an in-memory 'Handle' implementation.
-}
module KeyedVals.Handle.Mem (
  -- * functions
  new,

  -- * module re-exports
  module KeyedVals.Handle,
) where

import Control.Monad.IO.Unlift (MonadIO, MonadUnliftIO, liftIO)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import KeyedVals.Handle
import KeyedVals.Handle.Internal (Handle (..))
import Numeric.Natural (Natural)
import UnliftIO.STM (
  STM,
  TVar,
  atomically,
  newTVarIO,
  readTVar,
  writeTVar,
 )


-- | Create a new 'Handle'.
new :: MonadUnliftIO m => m (Handle m)
new :: forall (m :: * -> *). MonadUnliftIO m => m (Handle m)
new = do
  TVar (InMem, Bool)
v <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadIO m => a -> m (TVar a)
newTVarIO (forall a. Monoid a => a
mempty, Bool
False)
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
    Handle
      { hLoadVal :: ByteString -> m (Either HandleErr (Maybe ByteString))
hLoadVal = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> m (Either HandleErr (Maybe ByteString))
hLoadVal' TVar (InMem, Bool)
v
      , hSaveVal :: ByteString -> ByteString -> m (Either HandleErr ())
hSaveVal = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> ByteString -> m (Either HandleErr ())
hSaveVal' TVar (InMem, Bool)
v
      , hCountKVs :: ByteString -> m (Either HandleErr Natural)
hCountKVs = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool) -> ByteString -> m (Either HandleErr Natural)
hCountKVs' TVar (InMem, Bool)
v
      , hLoadKVs :: ByteString -> m (Either HandleErr ValsByKey)
hLoadKVs = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool) -> ByteString -> m (Either HandleErr ValsByKey)
hLoadKVs' TVar (InMem, Bool)
v
      , hSaveKVs :: ByteString -> ValsByKey -> m (Either HandleErr ())
hSaveKVs = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> ValsByKey -> m (Either HandleErr ())
hSaveKVs' TVar (InMem, Bool)
v
      , hUpdateKVs :: ByteString -> ValsByKey -> m (Either HandleErr ())
hUpdateKVs = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> ValsByKey -> m (Either HandleErr ())
hUpdateKVs' TVar (InMem, Bool)
v
      , hLoadFrom :: ByteString -> ByteString -> m (Either HandleErr (Maybe ByteString))
hLoadFrom = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> ByteString
-> m (Either HandleErr (Maybe ByteString))
hLoadFrom' TVar (InMem, Bool)
v
      , hSaveTo :: ByteString -> ByteString -> ByteString -> m (Either HandleErr ())
hSaveTo = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> ByteString
-> ByteString
-> m (Either HandleErr ())
hSaveTo' TVar (InMem, Bool)
v
      , hLoadSlice :: ByteString -> Selection -> m (Either HandleErr ValsByKey)
hLoadSlice = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> Selection -> m (Either HandleErr ValsByKey)
hLoadSlice' TVar (InMem, Bool)
v
      , hDeleteSelected :: Selection -> m (Either HandleErr ())
hDeleteSelected = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool) -> Selection -> m (Either HandleErr ())
hDeleteSelected' TVar (InMem, Bool)
v
      , hDeleteSelectedKVs :: ByteString -> Selection -> m (Either HandleErr ())
hDeleteSelectedKVs = forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> Selection -> m (Either HandleErr ())
hDeleteSelectedKVs' TVar (InMem, Bool)
v
      , hClose :: m ()
hClose = forall (m :: * -> *). MonadUnliftIO m => TVar (InMem, Bool) -> m ()
hClose' TVar (InMem, Bool)
v
      }


-- | Implement an in-memory 'Handle'.
type InMem = Map Key InMemValue


-- | Store an in-memory 'Handle'.
type InMemVar = TVar (InMem, Bool)


-- | InMemValue represents a value to be stored in an in-memory 'Handle'.
data InMemValue
  = Dict !ValsByKey
  | Simple !Val


hClose' :: MonadUnliftIO m => InMemVar -> m ()
hClose' :: forall (m :: * -> *). MonadUnliftIO m => TVar (InMem, Bool) -> m ()
hClose' TVar (InMem, Bool)
var = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$
  forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ do
    (InMem
fh, Bool
_) <- forall a. TVar a -> STM a
readTVar TVar (InMem, Bool)
var
    forall a. TVar a -> a -> STM ()
writeTVar TVar (InMem, Bool)
var (InMem
fh, Bool
True)


hLoadVal' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  m (Either HandleErr (Maybe Val))
hLoadVal' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> m (Either HandleErr (Maybe ByteString))
hLoadVal' TVar (InMem, Bool)
var ByteString
key = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> (Maybe InMemValue -> STM (Either HandleErr a))
-> m (Either HandleErr a)
withInMemKey TVar (InMem, Bool)
var ByteString
key forall a b. (a -> b) -> a -> b
$ \case
  Maybe InMemValue
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a. Maybe a
Nothing
  Just (Dict ValsByKey
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey
  Just (Simple ByteString
v) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just ByteString
v


hSaveVal' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  Val ->
  m (Either HandleErr ())
hSaveVal' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> ByteString -> m (Either HandleErr ())
hSaveVal' TVar (InMem, Bool)
var ByteString
key ByteString
value = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> (InMem -> STM (Either HandleErr a)) -> m (Either HandleErr a)
withInMem' TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \InMem
values -> do
  forall a err. TVar (a, Bool) -> a -> STM (Either err ())
updateInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
key (ByteString -> InMemValue
Simple ByteString
value) InMem
values


hLoadKVs' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  m (Either HandleErr ValsByKey)
hLoadKVs' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool) -> ByteString -> m (Either HandleErr ValsByKey)
hLoadKVs' TVar (InMem, Bool)
var ByteString
key = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> (Maybe InMemValue -> STM (Either HandleErr a))
-> m (Either HandleErr a)
withInMemKey TVar (InMem, Bool)
var ByteString
key forall a b. (a -> b) -> a -> b
$ \case
  Maybe InMemValue
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall k a. Map k a
Map.empty
  Just (Dict ValsByKey
v) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right ValsByKey
v
  Just (Simple ByteString
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey


hLoadSlice' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  Selection ->
  m (Either HandleErr ValsByKey)
hLoadSlice' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> Selection -> m (Either HandleErr ValsByKey)
hLoadSlice' TVar (InMem, Bool)
var ByteString
key Selection
sel = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> (Maybe InMemValue -> STM (Either HandleErr a))
-> m (Either HandleErr a)
withInMemKey TVar (InMem, Bool)
var ByteString
key forall a b. (a -> b) -> a -> b
$ \case
  Maybe InMemValue
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall k a. Map k a
Map.empty
  Just (Dict ValsByKey
v) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (forall p. Selection -> ByteString -> p -> Bool
predOf Selection
sel) ValsByKey
v
  Just (Simple ByteString
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey


hCountKVs' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  m (Either HandleErr Natural)
hCountKVs' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool) -> ByteString -> m (Either HandleErr Natural)
hCountKVs' TVar (InMem, Bool)
var ByteString
key = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> (Maybe InMemValue -> STM (Either HandleErr a))
-> m (Either HandleErr a)
withInMemKey TVar (InMem, Bool)
var ByteString
key forall a b. (a -> b) -> a -> b
$ \case
  Maybe InMemValue
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right Natural
0
  Just (Dict ValsByKey
v) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger forall a b. (a -> b) -> a -> b
$ forall k a. Map k a -> Int
Map.size ValsByKey
v
  Just (Simple ByteString
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey


hSaveKVs' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  ValsByKey ->
  m (Either HandleErr ())
hSaveKVs' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> ValsByKey -> m (Either HandleErr ())
hSaveKVs' TVar (InMem, Bool)
var ByteString
key ValsByKey
d = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> (InMem -> STM (Either HandleErr a)) -> m (Either HandleErr a)
withInMem' TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \InMem
values -> do
  forall a err. TVar (a, Bool) -> a -> STM (Either err ())
updateInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
key (ValsByKey -> InMemValue
Dict ValsByKey
d) InMem
values


hUpdateKVs' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  ValsByKey ->
  m (Either HandleErr ())
hUpdateKVs' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> ValsByKey -> m (Either HandleErr ())
hUpdateKVs' TVar (InMem, Bool)
var ByteString
key ValsByKey
d = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> (InMem -> STM (Either HandleErr a)) -> m (Either HandleErr a)
withInMem' TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \InMem
values ->
  case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ByteString
key InMem
values of
    Maybe InMemValue
Nothing -> do
      forall a err. TVar (a, Bool) -> a -> STM (Either err ())
updateInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
key (ValsByKey -> InMemValue
Dict ValsByKey
d) InMem
values
    Just (Dict ValsByKey
d') -> do
      forall a err. TVar (a, Bool) -> a -> STM (Either err ())
updateInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
key (ValsByKey -> InMemValue
Dict forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union ValsByKey
d ValsByKey
d') InMem
values
    Just (Simple ByteString
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey


updateInMem :: TVar (a, Bool) -> a -> STM (Either err ())
updateInMem :: forall a err. TVar (a, Bool) -> a -> STM (Either err ())
updateInMem TVar (a, Bool)
var a
newMap = do
  forall a. TVar a -> a -> STM ()
writeTVar TVar (a, Bool)
var (a
newMap, Bool
False)
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right ()


hSaveTo' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  Key ->
  Val ->
  m (Either HandleErr ())
hSaveTo' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> ByteString
-> ByteString
-> m (Either HandleErr ())
hSaveTo' TVar (InMem, Bool)
var ByteString
key ByteString
dictKey ByteString
value = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> (InMem -> STM (Either HandleErr a)) -> m (Either HandleErr a)
withInMem' TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \InMem
values ->
  case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ByteString
key InMem
values of
    Maybe InMemValue
Nothing -> do
      forall a err. TVar (a, Bool) -> a -> STM (Either err ())
updateInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
key (ValsByKey -> InMemValue
Dict forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton ByteString
dictKey ByteString
value) InMem
values
    Just (Dict ValsByKey
d) -> do
      forall a err. TVar (a, Bool) -> a -> STM (Either err ())
updateInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
key (ValsByKey -> InMemValue
Dict forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
dictKey ByteString
value ValsByKey
d) InMem
values
    Just (Simple ByteString
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey


hLoadFrom' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  Key ->
  m (Either HandleErr (Maybe Val))
hLoadFrom' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> ByteString
-> m (Either HandleErr (Maybe ByteString))
hLoadFrom' TVar (InMem, Bool)
var ByteString
key ByteString
dictKey = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> (Maybe InMemValue -> STM (Either HandleErr a))
-> m (Either HandleErr a)
withInMemKey TVar (InMem, Bool)
var ByteString
key forall a b. (a -> b) -> a -> b
$ \case
  Maybe InMemValue
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a. Maybe a
Nothing
  Just (Dict ValsByKey
d) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ByteString
dictKey ValsByKey
d
  Just (Simple ByteString
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey


hDeleteSelectedKVs' ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  Selection ->
  m (Either HandleErr ())
hDeleteSelectedKVs' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString -> Selection -> m (Either HandleErr ())
hDeleteSelectedKVs' TVar (InMem, Bool)
var ByteString
key Selection
sel = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> (InMem -> STM (Either HandleErr a)) -> m (Either HandleErr a)
withInMem' TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \InMem
values ->
  case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ByteString
key InMem
values of
    Maybe InMemValue
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right ()
    Just (Dict ValsByKey
d) -> do
      forall a. TVar a -> a -> STM ()
writeTVar TVar (InMem, Bool)
var (forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert ByteString
key (ValsByKey -> InMemValue
Dict (forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (forall p. Selection -> ByteString -> p -> Bool
notSel Selection
sel) ValsByKey
d)) InMem
values, Bool
False)
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right ()
    Just (Simple ByteString
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
BadKey


hDeleteSelected' ::
  MonadUnliftIO m =>
  InMemVar ->
  Selection ->
  m (Either HandleErr ())
hDeleteSelected' :: forall (m :: * -> *).
MonadUnliftIO m =>
TVar (InMem, Bool) -> Selection -> m (Either HandleErr ())
hDeleteSelected' TVar (InMem, Bool)
var Selection
sel = forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> (InMem -> STM (Either HandleErr a)) -> m (Either HandleErr a)
withInMem' TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \InMem
values -> do
  forall a. TVar a -> a -> STM ()
writeTVar TVar (InMem, Bool)
var (forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (forall p. Selection -> ByteString -> p -> Bool
notSel Selection
sel) InMem
values, Bool
False)
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right ()


notSel :: Selection -> Key -> p -> Bool
notSel :: forall p. Selection -> ByteString -> p -> Bool
notSel Selection
s ByteString
k p
_ = Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ ByteString
k ByteString -> Selection -> Bool
`isIn` Selection
s


predOf :: Selection -> Key -> p -> Bool
predOf :: forall p. Selection -> ByteString -> p -> Bool
predOf Selection
s ByteString
k p
_ = ByteString
k ByteString -> Selection -> Bool
`isIn` Selection
s


withInMem :: MonadIO m => TVar t -> (t -> STM a) -> m a
withInMem :: forall (m :: * -> *) t a.
MonadIO m =>
TVar t -> (t -> STM a) -> m a
withInMem TVar t
v t -> STM a
f = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically forall a b. (a -> b) -> a -> b
$ forall a. TVar a -> STM a
readTVar TVar t
v forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= t -> STM a
f


withInMem' ::
  MonadUnliftIO m =>
  InMemVar ->
  (InMem -> STM (Either HandleErr a)) ->
  m (Either HandleErr a)
withInMem' :: forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> (InMem -> STM (Either HandleErr a)) -> m (Either HandleErr a)
withInMem' TVar (InMem, Bool)
var InMem -> STM (Either HandleErr a)
f = forall (m :: * -> *) t a.
MonadIO m =>
TVar t -> (t -> STM a) -> m a
withInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \case
  (InMem
_, Bool
True) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
ConnectionClosed
  (InMem
values, Bool
_) -> InMem -> STM (Either HandleErr a)
f InMem
values


withInMemKey ::
  MonadUnliftIO m =>
  InMemVar ->
  Key ->
  (Maybe InMemValue -> STM (Either HandleErr a)) ->
  m (Either HandleErr a)
withInMemKey :: forall (m :: * -> *) a.
MonadUnliftIO m =>
TVar (InMem, Bool)
-> ByteString
-> (Maybe InMemValue -> STM (Either HandleErr a))
-> m (Either HandleErr a)
withInMemKey TVar (InMem, Bool)
var ByteString
key Maybe InMemValue -> STM (Either HandleErr a)
f = forall (m :: * -> *) t a.
MonadIO m =>
TVar t -> (t -> STM a) -> m a
withInMem TVar (InMem, Bool)
var forall a b. (a -> b) -> a -> b
$ \case
  (InMem
_, Bool
True) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left HandleErr
ConnectionClosed
  (InMem
values, Bool
_) -> Maybe InMemValue -> STM (Either HandleErr a)
f (forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ByteString
key InMem
values)