Improve caller readme and package description

caller/README.md

@@ -1,30 +1,68 @@
 # Caller
 
-Package caller is used to dynamicly call functions with data unmarshalled
+Package caller is used to dynamically call functions with data unmarshalled
-into the functions' first argument. It's main purpose is to hide common
+into the functions' first argument. Its main purpose is to hide common
-unmarshalling code from each function's implementation thus reducing
+unmarshalling code from each function implementation thus reducing
-boilerplate and making the code sexier.
+boilerplate and making package interaction code sexier.
 
 [Documentation](https://godoc.org/github.com/localhots/uberdaemon/caller)
 
+### Example
+
 ```go
 package main
 
 import (
+    "log"
     "github.com/localhots/uberdaemon/caller"
+    "github.com/path/to/package/messenger"
 )
 
-type message struct {
+type PriceUpdate struct {
-    Title string `json:"title"`
+    Product string  `json:"product"`
-    Body  string `json:"body"`
+    Amount  float32 `json:"amount"`
-}
-
-func processMessage(m message) {
-    fmt.Printf("Title: %s\nBody: %s\n", m.Title, m.Body)
 }
 
 func main() {
-    c, _ := caller.New(processMessage)
+    messenger.Subscribe("ProductPriceUpdates", func(p PriceUpdate) {
-    c.Call(`{"title": "Hello", "body": "World"}`)
+        log.Printf("Price for %q is now $%.2f", p.Product, p.Amount)
+    })
+    messenger.Deliver()
+}
+```
+
+Support code:
+
+```go
+package messenger
+
+import (
+    "github.com/localhots/uberdaemon/caller"
+)
+
+type item struct {
+    topic   string
+    payload []byte
+}
+
+var queue <-chan item
+var subscriptions = make(map[string][]*caller.Caller)
+
+func Subscribe(topic string, callback interface{}) {
+    c, err := caller.New(processMessage)
+    if err != nil {
+        panic(err)
+    }
+    subcriptions[topic] = append(subcriptions[topic], c)
+}
+
+func Deliver() {
+    for itm := range queue {
+        for _, c := range subscriptions[itm.topic] {
+            // Payload example:
+            // {"product": "Paperclip", "amount": 0.01}
+            c.Call(itm.payload)
+        }
+    }
 }
 ```

caller/caller.go

@@ -1,7 +1,7 @@
-// Package caller is used to dynamicly call functions with data unmarshalled
+// Package caller is used to dynamically call functions with data unmarshalled
-// into the functions' first argument. It's main purpose is to hide common
+// into the functions' first argument. Its main purpose is to hide common
-// unmarshalling code from each function's implementation thus reducing
+// unmarshalling code from each function implementation thus reducing
-// boilerplate and making the code sexier.
+// boilerplate and making package interaction code sexier.
 package caller
 
 import (