goderive

goderive derives mundane golang functions that you do not want to maintain and keeps them up to date.

It does this by parsing your go code for functions, which are not implemented, and then generates these functions for you by deriving their implementations from the input parameter types.

Examples

In the following code the deriveEqual function will be spotted as a function that was not implemented (or was previously derived) and has a prefix deriveEqual.

package main

type MyStruct struct {
	Int64     int64
	StringPtr *string
}

func (this *MyStruct) Equal(that *MyStruct) bool {
	return deriveEqual(this, that)
}

goderive will then generate the following code in a derived.gen.go file in the same package:

func deriveEqual(this, that *MyStruct) bool {
	return (this == nil && that == nil) ||
		this != nil && that != nil &&
			this.Int64 == that.Int64 &&
			((this.StringPtr == nil && that.StringPtr == nil) ||
        (this.StringPtr != nil && that.StringPtr != nil && *(this.StringPtr) == *(that.StringPtr)))
}

Recursive Examples:

Set Examples:

Functional Examples:

Concurrency Examples:

Pipeline
Do

Functions

Recursive Functions:

Equal
- deriveEqual(T, T) bool
- deriveEqual(T) func(T) bool
Compare
- deriveCompare(T, T) int
- deriveCompare(T) func(T) int
DeepCopy
- deriveDeepCopy(dst *T, src *T)
- deriveDeepCopy(dst []T, src []T)
- deriveDeepCopy(dst map[A]B, src map[A]B)
Clone deriveClone(T) T
GoString deriveGoString(T) string
Hash deriveHash(T) uint64

Set Functions:

Keys deriveKeys(map[K]V) []K
Sort deriveSort([]T) []T
Unique deriveUnique([]T) []T
Set deriveSet([]T) map[T]struct{}
Min
- deriveMin(list []T, default T) (min T)
- deriveMin(T, T) T
Max
- deriveMax(list []T, default T) (max T)
- deriveMax(T, T) T
Contains deriveContains([]T, T) bool
Intersect
- deriveIntersect(a, b []T) []T
- deriveIntersect(a, b map[T]struct{}) map[T]struct{}
Union
- deriveUnion(a, b []T) []T
- deriveUnion(a, b map[T]struct{}) map[T]struct{}

Functional Functions:

Fmap
- deriveFmap(func(A) B, []A) []B
- deriveFmap(func(rune) B, string) []B
- deriveFmap(func(A) B, func() (A, error)) (B, error)
- deriveFmap(func(A) (B, error), func() (A, error)) (func() (B, error), error)
- deriveFmap(func(A), func() (A, error)) error
- deriveFmap(func(A) (B, c, d, ...), func() (A, error)) (func() (B, c, d, ...), error)
Join
- deriveJoin([][]T) []T
- deriveJoin([]string) string
- deriveJoin(func() (T, error), error) func() (T, error)
- deriveJoin(func() (T, ..., error), error) func() (T, ..., error)
Filter deriveFilter(pred func(T) bool, []T) []T
All deriveAll(pred func(T) bool, []T) bool
Any deriveAny(pred func(T) bool, []T) bool
TakeWhile deriveTakeWhile(pred func(T) bool, []T) []T
Flip deriveFlip(f func(A, B, ...) T) func(B, A, ...) T
Curry deriveCurry(f func(A, B, ...) T) func(A) func(B, ...) T
Uncurry deriveUncurry(f func(A) func(B, ...) T) func(A, B, ...) T
Tuple deriveTuple(A, B, ...) func() (A, B, ...)
Compose
- deriveCompose(func() (A, error), func(A) (B, error)) func() (B, error)
- deriveCompose(func(A) (B, error), func(B) (C, error)) func(A) (C, error)
- deriveCompose(func(A...) (B..., error), func(B...) (C..., error)) func(A...) (C..., error)
- deriveCompose(func(A...) (B..., error), ..., func(C...) (D..., error)) func(A...) (D..., error)
Mem
- deriveMem(func(A...) (B...)) func(A...) (B...)
Traverse
- deriveTraverse(func(A) (B, error), []A) ([]B, error)
ToError
- deriveToError(error, func(A...) (B..., bool)) func(A...) (B..., error)
- deriveToError(error, func() bool) func() error
Apply deriveApply(f func(...A, B) C, B) func(...A) C

Concurrency Functions:

Fmap
- deriveFmap(func(A) B, <-chan A) <-chan B
Join
- deriveJoin(<-chan <-chan T) <-chan T
- deriveJoin(chan <-chan T) <-chan T
- deriveJoin([]<-chan T) <-chan T
- deriveJoin([]chan T) <-chan T
- deriveJoin(chan T, chan T, ...) <-chan T
Pipeline
- derivePipeline(func(A) <-chan B, func(B) <-chan C) func(A) <-chan C
Do
- deriveDo(func() (A, error), func (B, error)) (A, B, error)
Dup
- deriveDup(c <-chan T) (c1, c2 <-chan T)

When goderive walks over your code it is looking for a function that:

was not implemented (or was previously derived) and
has a predefined prefix.

Functions which have been previously derived will be regenerated to keep them up to date with the latest modifications to your types. This keeps these functions, which are truly mundane to write, maintainable.

For example when someone in your team adds a new field to a struct and forgets to update the CopyTo method. This problem is solved by goderive, by generating generated functions given the new types.

Function prefixes are by default deriveCamelCaseFunctionName, for example deriveEqual. These are customizable using command line flags.

You can derive functions for different types by using different suffixes with the same prefix. For example, if you wish to derive Equal for types MyStruct and MySecondStruct, name the functions deriveEqualMyStruct and deriveEqualMySecondStruct and goderive will derive both.

Let goderive edit your function names in your source code, by enabling autoname and dedup using the command line flags. These flags respectively make sure that your functions have unique names and that you don't generate multiple functions that do the same thing.

How to run

install the latest version of goderive globally using:

go install github.com/awalterschulze/goderive@latest

goderive can be run from the command line:

goderive ./...

, using the same path semantics as the go tool.

You can also run goderive using go generate

And you can customize specific function prefixes

Or you can customize all function prefixes

You can let goderive rename your functions using the -autoname and -dedup flags. If these flags are not used, goderive will not touch your code and rather return an error.

Customization

The derive package allows you to create your own code generator plugins, see all the current plugins for examples.

You can also create your own vanity binary. Including your own generators and/or customization of function prefixes, etc. This should be easy to figure out by looking at main.go

Inspired By

Haskell's deriving
Robert Griesemer's talk Prototype your design!
go/types standard library

Users

These projects use goderive:

Please let us know if you are using goderive by opening an issue or a pull request that adds your project to the list.

Mentioned

Please let us know if you mention goderive in a blog post, talk or go experience report, so that we can add a link to our list.

Presentations

2021-12: goderive: Code generation with Gonads - Go Cape Town meetup (code examples)

📚 goderive - Awesome Go Library for Generators

Detailed Description of goderive