module RingBuffers.Lifted ( RingBuffer , new , clear , append -- ,concat , capacity , filledLength , latest , foldMap ) where import qualified RingBuffers.Internal as I newtype RingBuffer a = RingBuffer (I.RingBuffer Array a) -- | Return a new ring buffer of the specified size. new :: () => Int -- ^ capacity of buffer -> IO (RingBuffer a) new sz = fmap coerce (I.new sz) -- | Reset the buffer to its empty state. clear :: () => RingBuffer a -- ^ buffer to clear -> IO () clear rb = I.clear (coerce rb) -- | Get the current filled length of the ring filledLength :: () => RingBuffer a -> IO Int filledLength rb = I.filledLength (coerce rb) -- | Get the maximum number of items the ring can contain capacity :: () => RingBuffer a -> IO Int capacity rb = I.capacity (coerce rb) -- | Retrieve the \(n\)th most-recently added item of the ring latest :: () => RingBuffer a -> Int -> IO (Maybe a) latest rb n = I.latest (coerce rb) n -- | Add an item to the end of the buffer. append :: () => a -> RingBuffer a -> IO () append x rb = I.append x (coerce rb) -- | Execute the given action with the items of the ring, accumulating its results. -- foldMap :: (Monoid b) => RingBuffer a -> (a -> IO b) -> IO b foldMap rb action = I.foldMap (coerce rb) action {- -- | Operate atomically on a buffer. withRing :: () => RingBuffer a -- ^ buffer to operate on -> (MutableArray RealWorld a -> RingState -> IO (RingState, r)) -- ^ function that takes a buffer, a ring state, and returns a new ring state with a value. -> IO r withRing rb f = I.withRing (coerce rb) f -- | Advance the ring buffer's state by the given number of elements advance :: () => Int -> (MutableArray RealWorld a -> RingState -> IO (RingState, ())) advance n = I.advance n -}