Functional programming for Golang
Switch branches/tags
Nothing to show
Clone or download
awalterschulze Merge pull request #49 from jeffbski/zero-for-bool-test
add test for compose returning boolean
Latest commit 2b2ac35 Sep 11, 2018

Readme.md

goderive

Build Status Go Report Card GoDoc

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:

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)

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

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

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.