[cabal] add homepage/bug-reports page

README.md

@@ -8,7 +8,7 @@ implementation using
 
 Current Haskell throttle implementations
 (e.g. [`Data.Conduit.Throttle`](https://hackage.haskell.org/package/conduit-throttle-0.3.1.0/docs/Data-Conduit-Throttle.html)
-or [`io-throttle](https://hackage.haskell.org/package/io-throttle))
+or [io-throttle](https://hackage.haskell.org/package/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.

haskell-throttle.cabal

@@ -20,14 +20,56 @@ name:               haskell-throttle
 -- PVP summary:     +-+------- breaking API changes
 --                  | | +----- non-breaking API additions
 --                  | | | +--- code changes with no API change
-version:            0.1.0.0
+version:            0.1.0.1
 
 -- A short (one-line) description of the package.
--- synopsis:
+synopsis: A simple throttling library, which drops messages from same group.
 
 -- A longer description of the package.
--- description:
-
+description:
+  A [throttle](https://en.wikipedia.org/wiki/Rate_limiting)
+  implementation using
+  [Control.Concurrent.STM.TChan](https://hackage.haskell.org/package/stm-2.5.3.1/docs/Control-Concurrent-STM-TChan.html).
+  
+  == Rationale
+  
+  Current Haskell throttle implementations
+  (e.g. [Data.Conduit.Throttle](https://hackage.haskell.org/package/conduit-throttle-0.3.1.0/docs/Data-Conduit-Throttle.html)
+  or [io-throttle](https://hackage.haskell.org/package/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](./src/Control/Concurrent/Throttle.hs):
+  
+    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](./test) 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.
+  
+        
 -- The license under which the package is released.
 license:            AGPL-3.0-or-later
 
@@ -40,6 +82,9 @@ author:             Przemysław Kamiński
 -- An email address to which users can send suggestions, bug reports, and patches.
 maintainer:         pk@intrepidus.pl
 
+homepage: https://gitlab.iscpif.fr/gargantext/haskell-throttle
+bug-reports: https://gitlab.iscpif.fr/gargantext/haskell-throttle/issues
+                    
 -- A copyright notice.
 -- copyright:
 category:           Concurrency