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:

• Equal
• Compare
• DeepCopy
• GoString
• Hash

Set Examples:

• Keys
• Sort
• Unique
• Set
• Min
• Max
• Contains
• Intersect
• Union

Functional Examples:

• Compose
• Mem
• Traverse
• ToError

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:

• DC/OS
• katydid
• go-geom
• gominikanren

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

• Monads for Go Programmers
• Golang Weekly
• Reddit
• Generating Equal methods for Go structs with goderive

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)