Implement Key interface for V5

Author: Nick Randall

README.md

@@ -9,7 +9,7 @@ This is an implementation of [Facebook's DataLoader](https://github.com/facebook
 This project is a work in progress. Feedback is encouraged.
 
 ## Install
-`go get -u gopkg.in/nicksrandall/dataloader.v4`
+`go get -u gopkg.in/nicksrandall/dataloader.v5`
 
 ## Usage
 ```go
@@ -103,6 +103,32 @@ type Cache interface {
 }
 ```
 
+## Upgrade from v4 to v5
+```diff
+// dataloader.Interface as now allows interace{} as key rather than string
+- loader.Load(context.Context, key interface{}) Thunk
++ loader.Load(ctx context.Context, key Key) Thunk
+- loader.LoadMany(context.Context, key []interface{}) ThunkMany
++ loader.LoadMany(ctx context.Context, keys Keys) ThunkMany
+- loader.Prime(context.Context, key interface{}, value interface{}) Interface
++ loader.Prime(ctx context.Context, key Key, value interface{}) Interface
+- loader.Clear(context.Context, key interface{}) Interface
++ loader.Clear(ctx context.Context, key Key) Interface
+```
+
+```diff
+// cache interface now allows interface{} as key instead of string
+type Cache interface {
+-	Get(context.Context, interface{}) (Thunk, bool)
++	Get(context.Context, Key) (Thunk, bool)
+-	Set(context.Context, interface{}, Thunk)
++	Set(context.Context, Key, Thunk)
+-	Delete(context.Context, interface{}) bool
++	Delete(context.Context, Key) bool
+	Clear()
+}
+```
+
 ### Don't need/want to use context?
 You're welcome to install the v1 version of this library.
 

cache.go

@@ -4,9 +4,9 @@ import "context"
 
 // The Cache interface. If a custom cache is provided, it must implement this interface.
 type Cache interface {
-	Get(context.Context, interface{}) (Thunk, bool)
-	Set(context.Context, interface{}, Thunk)
-	Delete(context.Context, interface{}) bool
+	Get(context.Context, Key) (Thunk, bool)
+	Set(context.Context, Key, Thunk)
+	Delete(context.Context, Key) bool
 	Clear()
 }
 
@@ -16,13 +16,13 @@ type Cache interface {
 type NoCache struct{}
 
 // Get is a NOOP
-func (c *NoCache) Get(context.Context, interface{}) (Thunk, bool) { return nil, false }
+func (c *NoCache) Get(context.Context, Key) (Thunk, bool) { return nil, false }
 
 // Set is a NOOP
-func (c *NoCache) Set(context.Context, interface{}, Thunk) { return }
+func (c *NoCache) Set(context.Context, Key, Thunk) { return }
 
 // Delete is a NOOP
-func (c *NoCache) Delete(context.Context, interface{}) bool { return false }
+func (c *NoCache) Delete(context.Context, Key) bool { return false }
 
 // Clear is a NOOP
 func (c *NoCache) Clear() { return }

dataloader.go

@@ -20,18 +20,18 @@ import (
 // different access permissions and consider creating a new instance per
 // web request.
 type Interface interface {
-	Load(context.Context, interface{}) Thunk
-	LoadMany(context.Context, []interface{}) ThunkMany
-	Clear(context.Context, string) Interface
+	Load(context.Context, Key) Thunk
+	LoadMany(context.Context, Keys) ThunkMany
+	Clear(context.Context, Key) Interface
 	ClearAll() Interface
-	Prime(ctx context.Context, key interface{}, value interface{}) Interface
+	Prime(ctx context.Context, key Key, value interface{}) Interface
 }
 
 // BatchFunc is a function, which when given a slice of keys (string), returns an slice of `results`.
 // It's important that the length of the input keys matches the length of the output results.
 //
 // The keys passed to this function are guaranteed to be unique
-type BatchFunc func(context.Context, []interface{}) []*Result
+type BatchFunc func(context.Context, Keys) []*Result
 
 // Result is the data structure that a BatchFunc returns.
 // It contains the resolved data, and any errors that may have occurred while fetching the data.
@@ -100,7 +100,7 @@ type ThunkMany func() ([]interface{}, []error)
 
 // type used to on input channel
 type batchRequest struct {
-	key     interface{}
+	key     Key
 	channel chan *Result
 }
 
@@ -191,7 +191,7 @@ func NewBatchedLoader(batchFn BatchFunc, opts ...Option) *Loader {
 }
 
 // Load load/resolves the given key, returning a channel that will contain the value and error
-func (l *Loader) Load(originalContext context.Context, key interface{}) Thunk {
+func (l *Loader) Load(originalContext context.Context, key Key) Thunk {
 	ctx, finish := l.tracer.TraceLoad(originalContext, key)
 
 	c := make(chan *Result, 1)
@@ -267,7 +267,7 @@ func (l *Loader) Load(originalContext context.Context, key interface{}) Thunk {
 }
 
 // LoadMany loads mulitiple keys, returning a thunk (type: ThunkMany) that will resolve the keys passed in.
-func (l *Loader) LoadMany(originalContext context.Context, keys []interface{}) ThunkMany {
+func (l *Loader) LoadMany(originalContext context.Context, keys Keys) ThunkMany {
 	ctx, finish := l.tracer.TraceLoadMany(originalContext, keys)
 
 	var (
@@ -278,15 +278,17 @@ func (l *Loader) LoadMany(originalContext context.Context, keys []interface{}) T
 		wg     sync.WaitGroup
 	)
 
+	resolve := func(ctx context.Context, i int) {
+		defer wg.Done()
+		thunk := l.Load(ctx, keys[i])
+		result, err := thunk()
+		data[i] = result
+		errors[i] = err
+	}
+
 	wg.Add(length)
 	for i := range keys {
-		go func(ctx context.Context, i int) {
-			defer wg.Done()
-			thunk := l.Load(ctx, keys[i])
-			result, err := thunk()
-			data[i] = result
-			errors[i] = err
-		}(ctx, i)
+		go resolve(ctx, i)
 	}
 
 	go func() {
@@ -333,7 +335,7 @@ func (l *Loader) LoadMany(originalContext context.Context, keys []interface{}) T
 }
 
 // Clear clears the value at `key` from the cache, it it exsits. Returs self for method chaining
-func (l *Loader) Clear(ctx context.Context, key string) Interface {
+func (l *Loader) Clear(ctx context.Context, key Key) Interface {
 	l.cacheLock.Lock()
 	l.cache.Delete(ctx, key)
 	l.cacheLock.Unlock()
@@ -351,7 +353,7 @@ func (l *Loader) ClearAll() Interface {
 
 // Prime adds the provided key and value to the cache. If the key already exists, no change is made.
 // Returns self for method chaining
-func (l *Loader) Prime(ctx context.Context, key interface{}, value interface{}) Interface {
+func (l *Loader) Prime(ctx context.Context, key Key, value interface{}) Interface {
 	if _, ok := l.cache.Get(ctx, key); !ok {
 		thunk := func() (interface{}, error) {
 			return value, nil
@@ -399,10 +401,12 @@ func (b *batcher) end() {
 
 // execute the batch of all items in queue
 func (b *batcher) batch(originalContext context.Context) {
-	var keys []interface{}
-	var reqs []*batchRequest
-	var items []*Result
-	var panicErr interface{}
+	var (
+		keys     = make(Keys, 0)
+		reqs     = make([]*batchRequest, 0)
+		items    = make([]*Result, 0)
+		panicErr interface{}
+	)
 
 	for item := range b.input {
 		keys = append(keys, item.key)