-- | 'TBQueue' helpers for static 'Concurrent' effect.
--
-- @since 0.1
module Effectful.Concurrent.STM.TBQueue.Static
  ( newTBQueueA,
    readTBQueueA,
    tryReadTBQueueA,
    writeTBQueueA,
    flushTBQueueA,

    -- * Re-exports
    Concurrent,
    runConcurrent,
    TBQueue,
    Natural,
  )
where

import Control.Concurrent.STM.TBQueue (TBQueue)
import Control.Concurrent.STM.TBQueue qualified as TBQueue
import Effectful (Eff, type (:>))
import Effectful.Concurrent.STM (Concurrent, atomically, runConcurrent)
import Numeric.Natural (Natural)

-- | @since 0.1
newTBQueueA :: (Concurrent :> es) => Natural -> Eff es (TBQueue a)
newTBQueueA :: forall (es :: [Effect]) a.
(Concurrent :> es) =>
Natural -> Eff es (TBQueue a)
newTBQueueA = STM (TBQueue a) -> Eff es (TBQueue a)
forall (es :: [Effect]) a. (Concurrent :> es) => STM a -> Eff es a
atomically (STM (TBQueue a) -> Eff es (TBQueue a))
-> (Natural -> STM (TBQueue a)) -> Natural -> Eff es (TBQueue a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> STM (TBQueue a)
forall a. Natural -> STM (TBQueue a)
TBQueue.newTBQueue

-- | @since 0.1
readTBQueueA :: (Concurrent :> es) => TBQueue a -> Eff es a
readTBQueueA :: forall (es :: [Effect]) a.
(Concurrent :> es) =>
TBQueue a -> Eff es a
readTBQueueA = STM a -> Eff es a
forall (es :: [Effect]) a. (Concurrent :> es) => STM a -> Eff es a
atomically (STM a -> Eff es a)
-> (TBQueue a -> STM a) -> TBQueue a -> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TBQueue a -> STM a
forall a. TBQueue a -> STM a
TBQueue.readTBQueue

-- | @since 0.1
tryReadTBQueueA :: (Concurrent :> es) => TBQueue a -> Eff es (Maybe a)
tryReadTBQueueA :: forall (es :: [Effect]) a.
(Concurrent :> es) =>
TBQueue a -> Eff es (Maybe a)
tryReadTBQueueA = STM (Maybe a) -> Eff es (Maybe a)
forall (es :: [Effect]) a. (Concurrent :> es) => STM a -> Eff es a
atomically (STM (Maybe a) -> Eff es (Maybe a))
-> (TBQueue a -> STM (Maybe a)) -> TBQueue a -> Eff es (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TBQueue a -> STM (Maybe a)
forall a. TBQueue a -> STM (Maybe a)
TBQueue.tryReadTBQueue

-- | @since 0.1
writeTBQueueA :: (Concurrent :> es) => TBQueue a -> a -> Eff es ()
writeTBQueueA :: forall (es :: [Effect]) a.
(Concurrent :> es) =>
TBQueue a -> a -> Eff es ()
writeTBQueueA TBQueue a
q = STM () -> Eff es ()
forall (es :: [Effect]) a. (Concurrent :> es) => STM a -> Eff es a
atomically (STM () -> Eff es ()) -> (a -> STM ()) -> a -> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TBQueue a -> a -> STM ()
forall a. TBQueue a -> a -> STM ()
TBQueue.writeTBQueue TBQueue a
q

-- | @since 0.1
flushTBQueueA :: (Concurrent :> es) => TBQueue a -> Eff es [a]
flushTBQueueA :: forall (es :: [Effect]) a.
(Concurrent :> es) =>
TBQueue a -> Eff es [a]
flushTBQueueA = STM [a] -> Eff es [a]
forall (es :: [Effect]) a. (Concurrent :> es) => STM a -> Eff es a
atomically (STM [a] -> Eff es [a])
-> (TBQueue a -> STM [a]) -> TBQueue a -> Eff es [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TBQueue a -> STM [a]
forall a. TBQueue a -> STM [a]
TBQueue.flushTBQueue