There comes some kind of description how to use this module.

Assume next import:

 import Data.Digest.TigerHash

Typical instant usage:

 instance TigerHashable k => TigerHashable (k, Message) where
     tigerHashUpdate ctx_ (key, Message {sender = data0, body = data1}) = do
         tigerHashUpdate ctx_ key
         tigerHashUpdate ctx_ data0
         tigerHashUpdate ctx_ data1

 signMessage :: TigerHashable k => k -> Message -> SignedMessage
 signMessage pkey msg = SignedMessage { message = msg, sign = tigerHash (pkey, msg) }

This is pretty useful when you need to send signed messages over public channel.

But using this in a such functional way have its drawbacks. Each time system requires calculation of hash it will issue prepearing of new context for each calculation instead of using the same context.

To solve that there is function for processing lazy list:

 hashMessageSenders :: [Message] -> [(TigerHash, Message)]
 hashMessageSenders msgs = zip (tigerHashList senders) msgs
     where senders = map sender msgs

This can be used for building hashed storage, which requires hash of each element.

Notice that while you expand each node of the list tigerHashList will calculate it's head for you. That's done with intention to loose overhead while hashing files for DC++ .