How to generalize function wrapping in Go?

Question

I have the following interface:

type Selector interface { SelectOne(ctx context.Context, one A) (Result, error) SelectTwo(ctx context.Context, one A, two B) ([]Result, error) SelectThree(ctx context.Context, one A, two B, three C) ([]Result, error) }

and the following implementations:

type Database struct{} func (d Database) SelectOne(...) (...) {...} func (d Database) SelectTwo(...) (...) {...} func (d Database) SelectThree(...) (...) {...}

Then, on top of that, I want to add a cache layer that uses the very nice github.com/hashicorp/golang-lru library:

type SelectorCache struct { db Database cacheOne *lru.Cache cacheTwo *lru.Cache } func (c SelectorCache) SelectOne(ctx context.Context, one A) (Result, error) { cached, ok := c.cacheOne.Get(makeKey(one)) if ok { casted, ok := cached.(Result) if ok { return casted, nil } } fetched, err := c.db.SelectOne(ctx, one) if err != nil { return Result{}, err } c.cache.Add(key, fetched) return fetched, nil } func (c SelectorCache) SelectTwo(ctx context.Context, one A, two B) ([]Result, error) { ... casted, ok := cached.([]Result) ... fetched, err := c.db.SelectTwo(ctx, one, two) ... } func () SelectThree(ctx context.Context, one A, two B, three C) ([]Result, error) { ... casted, ok := cached.([]Result) ... fetched, err := c.db.SelectThree(ctx, one, two, three) ... }

As you see, the cache layer is basically the same for each case with the only difference being in the underlying function. If that was Python, I could easily create a wrapper function that passes *a, **kw to the wrapped function. How can I rewrite that so the boilerplate gets gone?

Inian · Accepted Answer · 2020-09-07 11:58:38Z

You could write a variadic function (see Function types) that takes arbitrary number of ints as arguments(zero or more) and process them in one shot. For e.g.

func (d Database) Select(ctx context.Context, numbers ...int)

You could just iterate over numbers in a range for loop and perform your desired actions. Your function invocation can remain the same as before though.

fetched, err := c.db.Select(ctx, one) fetched, err := c.db.Select(ctx, one, two) fetched, err := c.db.Select(ctx, one, two, three)

Yeah, that's a simplified example, the argument types are also of different types. I was thinking of ...interface{}, but that would kill the whole thing, wouldn't it? :)
@qwe You could use variadic interfaces - stackoverflow.com/q/12334697

torek · Accepted Answer · 2020-09-07 21:43:08Z

You mention in a comment that the argument types vary.

In general, you can do this:

at compile-time, or
at run-time.

The run-time version is easier to code and use and is quite flexible, but of course has some runtime cost. Perhaps you are trying to avoid this (which is fine, but brings to mind the old adage about measuring before optimizing).

The compile-time version is what you've written in your example.

How can I rewrite that so the boilerplate gets gone?

For Go 1, there is only one way to do that: write a program to write your program. 😀 This is what go generate is all about. There is a Go blog post about it as well.

In Go 2, there will almost certainly be generics, and you can actually play with them a bit. They will be the way to do what you wanted.

Collectives™ on Stack Overflow

How to generalize function wrapping in Go?

2 Answers 2

2 Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Linked

Related