haskell-throttle

A simple throttling library, which drops messages from same group.

A throttle implementation using Control.Concurrent.STM.TChan.

Rationale

Current Haskell throttle implementations (e.g. Data.Conduit.Throttle or io-throttle) work by just slowing down incoming messages. However, sometimes we don't care about delivering all messages, but just want to limit their rate. Hence this module is born.

The main function is in Control.Concurrent.Throttle:

throttle :: (Ord id, Eq id, Show id) => Int -> TChan.TChan (id, a) -> (a -> IO ()) -> IO ()

It takes as arguments:

• resolution (in milliseconds)

• a `TChan` where `(id, a)` tuples are sent

• `action` which, for given `a` calls some `IO` action

In the above we have 2 types:

• `a` represents the incoming message which will be called with the supplied action

• `id` represents some identifier associated with the message. By using this `id` we can perform grouping of messages and throttle them accordingly.

The `throttle` function itself should be spawned in a separate thread. It then awaits for incoming messages on the given TChan.

See test directory for a sample usage.

Design

Currently, the `throttle` function spawns a `mapCleaner` thread which, periodically, checks the internal `TVar` value for values to clean up and values to hold before the given delay happens.