Code generation for enums from code comments.

# go-enum

[![Actions Status](https://github.com/abice/go-enum/actions/workflows/build_and_test.yml/badge.svg)](https://github.com/abice/go-enum/actions/workflows/build_and_test.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/abice/go-enum)](https://goreportcard.com/report/github.com/abice/go-enum)
[![Coverage Status](https://coveralls.io/repos/github/abice/go-enum/badge.svg)](https://coveralls.io/github/abice/go-enum)
[![GoDoc](https://godoc.org/github.com/abice/go-enum?status.svg)](https://godoc.org/github.com/abice/go-enum)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

An enum generator for go

## How it works

go-enum will take a commented type declaration like this:

```go
// ENUM(jpeg, jpg, png, tiff, gif)
type ImageType int
```

and generate a file with the iota definition along various optional niceties that you may need:

```go
const (
 // ImageTypeJpeg is a ImageType of type Jpeg.
 ImageTypeJpeg ImageType = iota
 // ImageTypeJpg is a ImageType of type Jpg.
 ImageTypeJpg
 // ImageTypePng is a ImageType of type Png.
 ImageTypePng
 // ImageTypeTiff is a ImageType of type Tiff.
 ImageTypeTiff
 // ImageTypeGif is a ImageType of type Gif.
 ImageTypeGif
)

// String implements the Stringer interface.
func (x ImageType) String() string

// ParseImageType attempts to convert a string to a ImageType.
func ParseImageType(name string) (ImageType, error)

// MarshalText implements the text marshaller method.
func (x ImageType) MarshalText() ([]byte, error)

// UnmarshalText implements the text unmarshaller method.
func (x *ImageType) UnmarshalText(text []byte) error
```

**Fear not the fact that the `MarshalText` and `UnmarshalText` are generated rather than JSON methods... they will still be utilized by the default JSON encoding methods.**

If you find that the options given are not adequate for your use case, there is an option to add a custom template (`-t` flag) to the processing engine so that your custom code can be created!

## Now with string typed enums

```go
// ENUM(pending, running, completed, failed)
type StrState string
```

```go
const (
 // StrStatePending is a StrState of type pending.
 StrStatePending StrState = "pending"
 // StrStateRunning is a StrState of type running.
 StrStateRunning StrState = "running"
 // StrStateCompleted is a StrState of type completed.
 StrStateCompleted StrState = "completed"
 // StrStateFailed is a StrState of type failed.
 StrStateFailed StrState = "failed"
)
```

If you would like to get integer values in sql, but strings elsewhere, you can assign an int value in the declaration
like always, and specify the `--sqlint` flag.  Those values will be then used to convey the int value to sql, while allowing you to use only strings elsewhere.
This might be helpful for things like swagger docs where you want the same type being used on the api layer, as you do in the
sql layer, and not have swagger assume that your enumerations are integers, but are in fact strings!

```go
// swagger:enum StrState
// ENUM(pending, running, completed, failed)
type StrState string
```

## Goal

The goal of go-enum is to create an easy to use enum generator that will take a decorated type declaration like `type EnumName int` and create the associated constant values and funcs that will make life a little easier for adding new values.
It's not perfect, but I think it's useful.

I took the output of the [Stringer](https://godoc.org/golang.org/x/tools/cmd/stringer) command as the `String()` method, and added a way to parse a string value.

## Docker image

You can now use a docker image directly for running the command if you do not wish to install anything!

```shell
   docker run -w /app -v $(pwd):/app abice/go-enum:$(GO_ENUM_VERSION)
```

## Installation

You can now download a release directly from github and use that for generating your enums! (Thanks to [GoReleaser](https://github.com/goreleaser/goreleaser-action))

I did not specify any overrides on the release binary names, so `uname -s` and `uname -m` should provide the correct version of the binary for your distro.

```shell
    curl -fsSL "https://github.com/abice/go-enum/releases/download/$(GO_ENUM_VERSION)/go-enum_$(uname -s)_$(uname -m)" -o go-enum
```

## Adding it to your project

### Using go generate

1. Add a go:generate line to your file like so... `//go:generate go-enum --marshal`
1. Run go generate like so `go generate ./...`
1. Enjoy your newly created Enumeration!

### Using Makefile

If you prefer makefile stuff, you can always do something like this:

```Makefile
STANDARD_ENUMS = ./example/animal_enum.go \
 ./example/color_enum.go

NULLABLE_ENUMS = ./example/sql_enum.go

$(STANDARD_ENUMS): GO_ENUM_FLAGS=--nocase --marshal --names --ptr
$(NULLABLE_ENUMS): GO_ENUM_FLAGS=--nocase --marshal --names --sqlnullint --ptr

enums: $(STANDARD_ENUMS) $(NULLABLE_ENUMS)

# The generator statement for go enum files.  Files that invalidate the
# enum file: source file, the binary itself, and this file (in case you want to generate with different flags)
%_enum.go: %.go $(GOENUM) Makefile
 $(GOENUM) -f $*.go $(GO_ENUM_FLAGS)
```

## Command options

``` shell
go-enum --help

NAME:
   go-enum - An enum generator for go

USAGE:
   go-enum [global options] [arguments...]

VERSION:
   example

GLOBAL OPTIONS:
   --file value, -f value [ --file value, -f value ]          The file(s) to generate enums.  Use more than one flag for more files. [$GOFILE]
   --noprefix                                                 Prevents the constants generated from having the Enum as a prefix. (default: false)
   --lower                                                    Adds lowercase variants of the enum strings for lookup. (default: false)
   --nocase                                                   Adds case insensitive parsing to the enumeration (forces lower flag). (default: false)
   --marshal                                                  Adds text (and inherently json) marshalling functions. (default: false)
   --sql                                                      Adds SQL database scan and value functions. (default: false)
   --sqlint                                                   Tells the generator that a string typed enum should be stored in sql as an integer value. (default: false)
   --flag                                                     Adds golang flag functions. (default: false)
   --prefix value                                             Adds a prefix with a user one. If you would like to replace the prefix, then combine this option with --noprefix.
   --names                                                    Generates a 'Names() []string' function, and adds the possible enum values in the error response during parsing (default: false)
   --values                                                   Generates a 'Values() []{{ENUM}}' function. (default: false)
   --nocamel                                                  Removes the snake_case to CamelCase name changing (default: false)
   --ptr                                                      Adds a pointer method to get a pointer from const values (default: false)
   --sqlnullint                                               Adds a Null{{ENUM}} type for marshalling a nullable int value to sql (default: false)
   --sqlnullstr                                               Adds a Null{{ENUM}} type for marshalling a nullable string value to sql.  If sqlnullint is specified too, it will be Null{{ENUM}}Str (default: false)
   --template value, -t value [ --template value, -t value ]  Additional template file(s) to generate enums.  Use more than one flag for more files. Templates will be executed in alphabetical order.
   --alias value, -a value [ --alias value, -a value ]        Adds or replaces aliases for a non alphanumeric value that needs to be accounted for. [Format should be "key:value,key2:value2", or specify multiple entries, or both!]
   --mustparse                                                Adds a Must version of the Parse that will panic on failure. (default: false)
   --forcelower                                               Forces a camel cased comment to generate lowercased names. (default: false)
   --forceupper                                               Forces a camel cased comment to generate uppercased names. (default: false)
   --nocomments                                               Removes auto generated comments.  If you add your own comments, these will still be created. (default: false)
   --buildtag value, -b value [ --buildtag value, -b value ]  Adds build tags to a generated enum file.
   --help, -h                                                 show help
   --version, -v                                              print the version
```

### Syntax

The parser looks for comments on your type defs and parse the enum declarations from it.
The parser will look for `ENUM(` and continue to look for comma separated values until it finds a `)`.  You can put values on the same line, or on multiple lines.\
If you need to have a specific value jump in the enum, you can now specify that by adding `=numericValue` to the enum declaration.  Keep in mind, this resets the data for all following values.  So if you specify `50` in the middle of an enum, each value after that will be `51, 52, 53...`

[Examples can be found in the example folder](./example/)

#### Comments

You can use comments inside enum that start with `//`\
The comment must be at the end of the same line as the comment value, only then it will be added as a comment to the generated constant.

```go
// Commented is an enumeration of commented values
/*
ENUM(
value1 // Commented value 1
value2
value3 // Commented value 3
)
*/
type Commented int
```

The generated comments in code will look something like:

```go
...
const (
    // CommentedValue1 is a Commented of type Value1
    // Commented value 1
    CommentedValue1 Commented = iota
    // CommentedValue2 is a Commented of type Value2
    CommentedValue2
    // CommentedValue3 is a Commented of type Value3
    // Commented value 3
    CommentedValue3
)
...
```

#### Example

There are a few examples in the `example` [directory](./example/).
I've included one here for easy access, but can't guarantee it's up to date.

``` go
// Color is an enumeration of colors that are allowed.
/* ENUM(
Black, White, Red
Green = 33 // Green starts with 33
*/
// Blue
// grey=
// yellow
// blue-green
// red-orange
// yellow_green
// red-orange-blue
// )
type Color int32
```

The generated code will look something like:

``` go
// Code generated by go-enum DO NOT EDIT.
// Version: example
// Revision: example
// Build Date: example
// Built By: example

package example

import (
 "fmt"
 "strings"
)

const (
 // ColorBlack is a Color of type Black.
 ColorBlack Color = iota
 // ColorWhite is a Color of type White.
 ColorWhite
 // ColorRed is a Color of type Red.
 ColorRed
 // ColorGreen is a Color of type Green.
 // Green starts with 33
 ColorGreen Color = iota + 30
 // ColorBlue is a Color of type Blue.
 ColorBlue
 // ColorGrey is a Color of type Grey.
 ColorGrey
 // ColorYellow is a Color of type Yellow.
 ColorYellow
 // ColorBlueGreen is a Color of type Blue-Green.
 ColorBlueGreen
 // ColorRedOrange is a Color of type Red-Orange.
 ColorRedOrange
 // ColorYellowGreen is a Color of type Yellow_green.
 ColorYellowGreen
 // ColorRedOrangeBlue is a Color of type Red-Orange-Blue.
 ColorRedOrangeBlue
)

const _ColorName = "BlackWhiteRedGreenBluegreyyellowblue-greenred-orangeyellow_greenred-orange-blue"

var _ColorMap = map[Color]string{
 ColorBlack:         _ColorName[0:5],
 ColorWhite:         _ColorName[5:10],
 ColorRed:           _ColorName[10:13],
 ColorGreen:         _ColorName[13:18],
 ColorBlue:          _ColorName[18:22],
 ColorGrey:          _ColorName[22:26],
 ColorYellow:        _ColorName[26:32],
 ColorBlueGreen:     _ColorName[32:42],
 ColorRedOrange:     _ColorName[42:52],
 ColorYellowGreen:   _ColorName[52:64],
 ColorRedOrangeBlue: _ColorName[64:79],
}

// String implements the Stringer interface.
func (x Color) String() string {
 if str, ok := _ColorMap[x]; ok {
  return str
 }
 return fmt.Sprintf("Color(%d)", x)
}

var _ColorValue = map[string]Color{
 _ColorName[0:5]:                    ColorBlack,
 strings.ToLower(_ColorName[0:5]):   ColorBlack,
 _ColorName[5:10]:                   ColorWhite,
 strings.ToLower(_ColorName[5:10]):  ColorWhite,
 _ColorName[10:13]:                  ColorRed,
 strings.ToLower(_ColorName[10:13]): ColorRed,
 _ColorName[13:18]:                  ColorGreen,
 strings.ToLower(_ColorName[13:18]): ColorGreen,
 _ColorName[18:22]:                  ColorBlue,
 strings.ToLower(_ColorName[18:22]): ColorBlue,
 _ColorName[22:26]:                  ColorGrey,
 strings.ToLower(_ColorName[22:26]): ColorGrey,
 _ColorName[26:32]:                  ColorYellow,
 strings.ToLower(_ColorName[26:32]): ColorYellow,
 _ColorName[32:42]:                  ColorBlueGreen,
 strings.ToLower(_ColorName[32:42]): ColorBlueGreen,
 _ColorName[42:52]:                  ColorRedOrange,
 strings.ToLower(_ColorName[42:52]): ColorRedOrange,
 _ColorName[52:64]:                  ColorYellowGreen,
 strings.ToLower(_ColorName[52:64]): ColorYellowGreen,
 _ColorName[64:79]:                  ColorRedOrangeBlue,
 strings.ToLower(_ColorName[64:79]): ColorRedOrangeBlue,
}

// ParseColor attempts to convert a string to a Color
func ParseColor(name string) (Color, error) {
 if x, ok := _ColorValue[name]; ok {
  return x, nil
 }
 return Color(0), fmt.Errorf("%s is not a valid Color", name)
}

func (x Color) Ptr() *Color {
 return &x
}

// MarshalText implements the text marshaller method
func (x Color) MarshalText() ([]byte, error) {
 return []byte(x.String()), nil
}

// UnmarshalText implements the text unmarshaller method
func (x *Color) UnmarshalText(text []byte) error {
 name := string(text)
 tmp, err := ParseColor(name)
 if err != nil {
  return err
 }
 *x = tmp
 return nil
}
```


go-enum

# go-linq [![GoDoc](https://godoc.org/github.com/ahmetb/go-linq?status.svg)](https://godoc.org/github.com/ahmetb/go-linq) [![Build Status](https://travis-ci.org/ahmetb/go-linq.svg?branch=master)](https://travis-ci.org/ahmetb/go-linq) [![Coverage Status](https://coveralls.io/repos/github/ahmetb/go-linq/badge.svg?branch=master)](https://coveralls.io/github/ahmetb/go-linq?branch=master) [![Go Report Card](https://goreportcard.com/badge/github.com/ahmetb/go-linq)](https://goreportcard.com/report/github.com/ahmetb/go-linq)

A powerful language integrated query (LINQ) library for Go.

* Written in vanilla Go, no dependencies!
* Complete lazy evaluation with iterator pattern
* Safe for concurrent use
* Supports generic functions to make your code cleaner and free of type assertions
* Supports arrays, slices, maps, strings, channels and custom collections

## Installation

When used with Go modules, use the following import path:

    go get github.com/ahmetb/go-linq/v3

Older versions of Go using different dependency management tools can use the
following import path to prevent breaking API changes:

    go get gopkg.in/ahmetb/go-linq.v3

## Quickstart

Usage is as easy as chaining methods like:

`From(slice)` `.Where(predicate)` `.Select(selector)` `.Union(data)`

**Example 1: Find all owners of cars manufactured after 2015**

```go
import . "github.com/ahmetb/go-linq/v3"

type Car struct {
    year int
    owner, model string
}

...


var owners []string

From(cars).Where(func(c interface{}) bool {
	return c.(Car).year >= 2015
}).Select(func(c interface{}) interface{} {
	return c.(Car).owner
}).ToSlice(&owners)
```

Or, you can use generic functions, like `WhereT` and `SelectT` to simplify your code
(at a performance penalty):

```go
var owners []string

From(cars).WhereT(func(c Car) bool {
	return c.year >= 2015
}).SelectT(func(c Car) string {
	return c.owner
}).ToSlice(&owners)
```

**Example 2: Find the author who has written the most books**

```go
import . "github.com/ahmetb/go-linq/v3"

type Book struct {
	id      int
	title   string
	authors []string
}

author := From(books).SelectMany( // make a flat array of authors
	func(book interface{}) Query {
		return From(book.(Book).authors)
	}).GroupBy( // group by author
	func(author interface{}) interface{} {
		return author // author as key
	}, func(author interface{}) interface{} {
		return author // author as value
	}).OrderByDescending( // sort groups by its length
	func(group interface{}) interface{} {
		return len(group.(Group).Group)
	}).Select( // get authors out of groups
	func(group interface{}) interface{} {
		return group.(Group).Key
	}).First() // take the first author
```

**Example 3: Implement a custom method that leaves only values greater than the specified threshold**

```go
type MyQuery Query

func (q MyQuery) GreaterThan(threshold int) Query {
	return Query{
		Iterate: func() Iterator {
			next := q.Iterate()

			return func() (item interface{}, ok bool) {
				for item, ok = next(); ok; item, ok = next() {
					if item.(int) > threshold {
						return
					}
				}

				return
			}
		},
	}
}

result := MyQuery(Range(1,10)).GreaterThan(5).Results()
```

## Generic Functions

Although Go doesn't implement generics, with some reflection tricks, you can use go-linq without
typing `interface{}`s and type assertions. This will introduce a performance penalty (5x-10x slower)
but will yield in a cleaner and more readable code.

Methods with `T` suffix (such as `WhereT`) accept functions with generic types. So instead of

    .Select(func(v interface{}) interface{} {...})

you can type:

    .SelectT(func(v YourType) YourOtherType {...})

This will make your code free of `interface{}` and type assertions.

**Example 4: "MapReduce" in a slice of string sentences to list the top 5 most used words using generic functions**

```go
var results []string

From(sentences).
	// split sentences to words
	SelectManyT(func(sentence string) Query {
		return From(strings.Split(sentence, " "))
	}).
	// group the words
	GroupByT(
		func(word string) string { return word },
		func(word string) string { return word },
	).
	// order by count
	OrderByDescendingT(func(wordGroup Group) int {
		return len(wordGroup.Group)
	}).
	// order by the word
	ThenByT(func(wordGroup Group) string {
		return wordGroup.Key.(string)
	}).
	Take(5).  // take the top 5
	// project the words using the index as rank
	SelectIndexedT(func(index int, wordGroup Group) string {
		return fmt.Sprintf("Rank: #%d, Word: %s, Counts: %d", index+1, wordGroup.Key, len(wordGroup.Group))
	}).
	ToSlice(&results)
```

**More examples** can be found in the [documentation](https://godoc.org/github.com/ahmetb/go-linq).

## Release Notes

```text
v3.2.0 (2020-12-29)
* Added FromChannelT().
* Added DefaultIfEmpty().

v3.1.0 (2019-07-09)
* Support for Go modules
* Added IndexOf()/IndexOfT().

v3.0.0 (2017-01-10)
* Breaking change: ToSlice() now overwrites existing slice starting
  from index 0 and grows/reslices it as needed.
* Generic methods support (thanks @cleitonmarx!)
  - Accepting parametrized functions was originally proposed in #26
  - You can now avoid type assertions and interface{}s
  - Functions with generic methods are named as "MethodNameT" and
    signature for the existing LINQ methods are unchanged.
* Added ForEach(), ForEachIndexed() and AggregateWithSeedBy().

v2.0.0 (2016-09-02)
* IMPORTANT: This release is a BREAKING CHANGE. The old version
  is archived at the 'archive/0.9' branch or the 0.9 tags.
* A COMPLETE REWRITE of go-linq with better performance and memory
  efficiency. (thanks @kalaninja!)
* API has significantly changed. Most notably:
  - linq.T removed in favor of interface{}
  - library methods no longer return errors
  - PLINQ removed for now (see channels support)
  - support for channels, custom collections and comparables

v0.9-rc4
* GroupBy()

v0.9-rc3.2
* bugfix: All() iterating over values instead of indices

v0.9-rc3.1
* bugfix: modifying result slice affects subsequent query methods

v0.9-rc3
* removed FirstOrNil, LastOrNil, ElementAtOrNil methods

v0.9-rc2.5
* slice-accepting methods accept slices of any type with reflections

v0.9-rc2
* parallel linq (plinq) implemented
* Queryable separated into Query & ParallelQuery
* fixed early termination for All

v0.9-rc1
* many linq methods are implemented
* methods have error handling support
* type assertion limitations are unresolved
* travis-ci.org build integrated
* open sourced on github, master & dev branches
```


go-linq

# goderive

[![Build Status](https://github.com/awalterschulze/goderive/actions/workflows/go.yaml/badge.svg?branch=master)](https://github.com/awalterschulze/goderive/actions)
[![Go Report Card](https://goreportcard.com/badge/github.com/awalterschulze/goderive)](https://goreportcard.com/report/github.com/awalterschulze/goderive)
[![GoDoc](https://img.shields.io/badge/godoc-reference-5272B4.svg?style=flat-square.svg)](https://godoc.org/github.com/awalterschulze/goderive)

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

<a href="http://www.youtube.com/watch?feature=player_embedded&v=qFYByoGFIUE" target="_blank">
 <img src="https://img.youtube.com/vi/qFYByoGFIUE/maxres2.jpg" alt="Watch the video" width="480" border="10" />
</a>

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`.

```go
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:

```go
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](https://github.com/awalterschulze/goderive/tree/master/example/plugin/equal)
  - [Compare](https://github.com/awalterschulze/goderive/tree/master/example/plugin/compare)
  - [DeepCopy](https://github.com/awalterschulze/goderive/tree/master/example/plugin/deepcopy)
  - [GoString](https://github.com/awalterschulze/goderive/tree/master/example/plugin/gostring)
  - [Hash](https://github.com/awalterschulze/goderive/tree/master/example/plugin/hash)

Set Examples:

  - [Keys](https://github.com/awalterschulze/goderive/tree/master/example/plugin/keys)
  - [Sort](https://github.com/awalterschulze/goderive/tree/master/example/plugin/sort)
  - [Unique](https://github.com/awalterschulze/goderive/tree/master/example/plugin/unique)
  - [Set](https://github.com/awalterschulze/goderive/tree/master/example/plugin/set)
  - [Min](https://github.com/awalterschulze/goderive/tree/master/example/plugin/min)
  - [Max](https://github.com/awalterschulze/goderive/tree/master/example/plugin/max)
  - [Contains](https://github.com/awalterschulze/goderive/tree/master/example/plugin/contains)
  - [Intersect](https://github.com/awalterschulze/goderive/tree/master/example/plugin/intersect)
  - [Union](https://github.com/awalterschulze/goderive/tree/master/example/plugin/union)

Functional Examples:

  - [Compose](https://github.com/awalterschulze/goderive/tree/master/example/plugin/compose)
  - [Mem](https://github.com/awalterschulze/goderive/tree/master/example/plugin/mem)
  - [Traverse](https://github.com/awalterschulze/goderive/tree/master/example/plugin/traverse)
  - [ToError](https://github.com/awalterschulze/goderive/tree/master/example/plugin/toerror)

Concurrency Examples:

  - [Pipeline](https://github.com/awalterschulze/goderive/tree/master/example/plugin/pipeline)
  - [Do](https://github.com/awalterschulze/goderive/tree/master/example/plugin/do)

## Functions

Recursive Functions:

  - [Equal](http://godoc.org/github.com/awalterschulze/goderive/plugin/equal)
    - `deriveEqual(T, T) bool`
    - `deriveEqual(T) func(T) bool`
  - [Compare](http://godoc.org/github.com/awalterschulze/goderive/plugin/compare)
    - `deriveCompare(T, T) int`
    - `deriveCompare(T) func(T) int`
  - [DeepCopy](http://godoc.org/github.com/awalterschulze/goderive/plugin/deepcopy)
    - `deriveDeepCopy(dst *T, src *T)`
    - `deriveDeepCopy(dst []T, src []T)`
    - `deriveDeepCopy(dst map[A]B, src map[A]B)`
  - [Clone](http://godoc.org/github.com/awalterschulze/goderive/plugin/clone) `deriveClone(T) T`
  - [GoString](http://godoc.org/github.com/awalterschulze/goderive/plugin/gostring) `deriveGoString(T) string`
  - [Hash](http://godoc.org/github.com/awalterschulze/goderive/plugin/hash) `deriveHash(T) uint64`

Set Functions:

  - [Keys](http://godoc.org/github.com/awalterschulze/goderive/plugin/keys) `deriveKeys(map[K]V) []K`
  - [Sort](http://godoc.org/github.com/awalterschulze/goderive/plugin/sort) `deriveSort([]T) []T`
  - [Unique](http://godoc.org/github.com/awalterschulze/goderive/plugin/unique) `deriveUnique([]T) []T`
  - [Set](http://godoc.org/github.com/awalterschulze/goderive/plugin/set) `deriveSet([]T) map[T]struct{}`
  - [Min](http://godoc.org/github.com/awalterschulze/goderive/plugin/min)
    - `deriveMin(list []T, default T) (min T)`
    - `deriveMin(T, T) T`
  - [Max](http://godoc.org/github.com/awalterschulze/goderive/plugin/max)
    - `deriveMax(list []T, default T) (max T)`
    - `deriveMax(T, T) T`
  - [Contains](http://godoc.org/github.com/awalterschulze/goderive/plugin/contains) `deriveContains([]T, T) bool`
  - [Intersect](http://godoc.org/github.com/awalterschulze/goderive/plugin/intersect)
    - `deriveIntersect(a, b []T) []T`
    - `deriveIntersect(a, b map[T]struct{}) map[T]struct{}`
  - [Union](http://godoc.org/github.com/awalterschulze/goderive/plugin/union)
    - `deriveUnion(a, b []T) []T`
    - `deriveUnion(a, b map[T]struct{}) map[T]struct{}`

Functional Functions:

  - [Fmap](http://godoc.org/github.com/awalterschulze/goderive/plugin/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](http://godoc.org/github.com/awalterschulze/goderive/plugin/join)
    - `deriveJoin([][]T) []T`
    - `deriveJoin([]string) string`
    - `deriveJoin(func() (T, error), error) func() (T, error)`
    - `deriveJoin(func() (T, ..., error), error) func() (T, ..., error)`
  - [Filter](http://godoc.org/github.com/awalterschulze/goderive/plugin/filter) `deriveFilter(pred func(T) bool, []T) []T`
  - [All](http://godoc.org/github.com/awalterschulze/goderive/plugin/all) `deriveAll(pred func(T) bool, []T) bool`
  - [Any](http://godoc.org/github.com/awalterschulze/goderive/plugin/any) `deriveAny(pred func(T) bool, []T) bool`
  - [TakeWhile](http://godoc.org/github.com/awalterschulze/goderive/plugin/takewhile) `deriveTakeWhile(pred func(T) bool, []T) []T`
  - [Flip](http://godoc.org/github.com/awalterschulze/goderive/plugin/flip) `deriveFlip(f func(A, B, ...) T) func(B, A, ...) T`
  - [Curry](http://godoc.org/github.com/awalterschulze/goderive/plugin/curry) `deriveCurry(f func(A, B, ...) T) func(A) func(B, ...) T`
  - [Uncurry](http://godoc.org/github.com/awalterschulze/goderive/plugin/uncurry) `deriveUncurry(f func(A) func(B, ...) T) func(A, B, ...) T`
  - [Tuple](http://godoc.org/github.com/awalterschulze/goderive/plugin/tuple) `deriveTuple(A, B, ...) func() (A, B, ...)`
  - [Compose](http://godoc.org/github.com/awalterschulze/goderive/plugin/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](http://godoc.org/github.com/awalterschulze/goderive/plugin/mem)
    - `deriveMem(func(A...) (B...)) func(A...) (B...)`
  - [Traverse](http://godoc.org/github.com/awalterschulze/goderive/plugin/traverse)
    - `deriveTraverse(func(A) (B, error), []A) ([]B, error)`
  - [ToError](http://godoc.org/github.com/awalterschulze/goderive/plugin/toerror)
    - `deriveToError(error, func(A...) (B..., bool)) func(A...) (B..., error)`
    - `deriveToError(error, func() bool) func() error`
  - [Apply](http://godoc.org/github.com/awalterschulze/goderive/plugin/apply) `deriveApply(f func(...A, B) C, B) func(...A) C`

Concurrency Functions:
  - [Fmap](http://godoc.org/github.com/awalterschulze/goderive/plugin/fmap)
    - `deriveFmap(func(A) B, <-chan A) <-chan B`
  - [Join](http://godoc.org/github.com/awalterschulze/goderive/plugin/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](http://godoc.org/github.com/awalterschulze/goderive/plugin/pipeline)
    - `derivePipeline(func(A) <-chan B, func(B) <-chan C) func(A) <-chan C`
  - [Do](http://godoc.org/github.com/awalterschulze/goderive/plugin/do)
    - `deriveDo(func() (A, error), func (B, error)) (A, B, error)`
  - [Dup](http://godoc.org/github.com/awalterschulze/goderive/plugin/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](https://github.com/awalterschulze/goderive/blob/master/example/gogenerate/example.go)

[And you can customize specific function prefixes](https://github.com/awalterschulze/goderive/blob/master/example/pluginprefix/Makefile)

[Or you can customize all function prefixes](https://github.com/awalterschulze/goderive/blob/master/example/prefix/Makefile)

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](https://github.com/awalterschulze/goderive/blob/master/main.go)

## Inspired By

  - Haskell's deriving
  - Robert Griesemer's talk [Prototype your design!](https://www.youtube.com/watch?v=vLxX3yZmw5Q)
  - [go/types](https://golang.org/pkg/go/types/) standard library

## Users

These projects use goderive:

  - [DC/OS](https://github.com/dcos/dcos-cli/blob/af0434c0ca80cee7152a1880770dc878501b9ac5/pkg/httpclient/derived.gen.go)
  - [katydid](https://github.com/katydid/katydid/blob/master/relapse/ast/derived.gen.go)
  - [go-geom](https://github.com/twpayne/go-geom/blob/master/derived.gen.go)
  - [gominikanren](https://github.com/awalterschulze/gominikanren/blob/master/micro/derived.gen.go)

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](https://medium.com/@awalterschulze/monads-for-go-programmers-6cda2b978cb1)
  - [Golang Weekly](https://golangweekly.com/issues/174)
  - [Reddit](https://www.reddit.com/r/programmingcirclejerk/comments/6vkkdw/this_is_what_goprogrammers_have_to_do_because/)
  - [Generating `Equal` methods for Go structs with `goderive`](https://www.jvt.me/posts/2023/03/27/go-generate-equal-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](https://www.youtube.com/watch?v=qFYByoGFIUE) - Go Cape Town meetup ([code examples](https://github.com/awalterschulze/goderive/blob/master/example/talk))


goderive

Generate converters by defining an interface.

<p align="center">
    <img width="300" src=".github/logo.svg" />
</p>

<h1 align="center">goverter</h1>
<p align="center"><i>a "type-safe Go converter" generator</i></p>
<p align="center">
    <a href="https://github.com/jmattheis/goverter/actions/workflows/build.yml">
        <img alt="Build Status" src="https://github.com/jmattheis/goverter/actions/workflows/build.yml/badge.svg">
    </a>
     <a href="https://codecov.io/gh/jmattheis/goverter">
        <img alt="codecov" src="https://codecov.io/gh/jmattheis/goverter/branch/main/graph/badge.svg">
    </a>
    <a href="https://goreportcard.com/report/github.com/jmattheis/goverter">
        <img alt="Go Report Card" src="https://goreportcard.com/badge/github.com/jmattheis/goverter">
    </a>
    <a href="https://pkg.go.dev/github.com/jmattheis/goverter">
        <img alt="Go Reference" src="https://pkg.go.dev/badge/github.com/jmattheis/goverter.svg">
    </a>
    <a href="https://github.com/jmattheis/goverter/releases/latest">
        <img alt="latest release" src="https://img.shields.io/github/release/jmattheis/goverter.svg">
    </a>
</p>

goverter is a tool for creating type-safe converters. All you have to
do is create an interface and execute goverter. The project is meant as
alternative to [jinzhu/copier](https://github.com/jinzhu/copier) that doesn't
use reflection.

[Getting Started](https://goverter.jmattheis.de/guide/getting-started) ᛫
[Installation](https://goverter.jmattheis.de/guide/install) ᛫
[CLI](https://goverter.jmattheis.de/reference/cli) ᛫
[Config](https://goverter.jmattheis.de/reference/settings)

## Features

- **Fast execution**: No reflection is used at runtime
- Automatically converts builtin types: slices, maps, named types, primitive
  types, pointers, structs with same fields
- [Enum support](https://goverter.jmattheis.de/guide/enum)
- [Deep copies](https://en.wikipedia.org/wiki/Object_copying#Deep_copy) per
  default and supports [shallow
  copying](https://en.wikipedia.org/wiki/Object_copying#Shallow_copy)
- **Customizable**: [You can implement custom converter methods](https://goverter.jmattheis.de/reference/extend)
- [Clear errors when generating the conversion methods](https://goverter.jmattheis.de/guide/error-early) if
  - the target struct has unmapped fields
  - types cannot be converted without losing information
- Detailed [documentation](https://goverter.jmattheis.de/) with a lot examples
- Thoroughly tested, see [our test scenarios](./scenario)

## Example

Given this converter:

```go
package example

// goverter:converter
type Converter interface {
    ConvertItems(source []Input) []Output

    // goverter:ignore Irrelevant
    // goverter:map Nested.AgeInYears Age
    Convert(source Input) Output
}

type Input struct {
    Name string
    Nested InputNested
}
type InputNested struct {
    AgeInYears int
}
type Output struct {
    Name string
    Age int
    Irrelevant bool
}
```

Goverter will generated these conversion methods:

```go
package generated

import example "goverter/example"

type ConverterImpl struct{}

func (c *ConverterImpl) Convert(source example.Input) example.Output {
    var exampleOutput example.Output
    exampleOutput.Name = source.Name
    exampleOutput.Age = source.Nested.AgeInYears
    return exampleOutput
}
func (c *ConverterImpl) ConvertItems(source []example.Input) []example.Output {
    var exampleOutputList []example.Output
    if source != nil {
        exampleOutputList = make([]example.Output, len(source))
        for i := 0; i < len(source); i++ {
            exampleOutputList[i] = c.Convert(source[i])
        }
    }
    return exampleOutputList
}
```

See [Getting Started](https://goverter.jmattheis.de/guide/getting-started).

## Versioning

goverter uses [SemVer](http://semver.org/) for versioning the cli.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE)
file for details

_Logo by [MariaLetta](https://github.com/MariaLetta)_


goverter

Generate decorators for Go interfaces using simple templates.

# GoWrap
[![License](https://img.shields.io/badge/license-mit-green.svg)](https://github.com/hexdigest/gowrap/blob/master/LICENSE)
[![Build](https://github.com/hexdigest/gowrap/actions/workflows/go.yml/badge.svg)](https://github.com/hexdigest/gowrap/actions/workflows/go.yml)
[![Coverage Status](https://coveralls.io/repos/github/hexdigest/gowrap/badge.svg?branch=master)](https://coveralls.io/github/hexdigest/gowrap?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/hexdigest/gowrap?dropcache)](https://goreportcard.com/report/github.com/hexdigest/gowrap)
[![GoDoc](https://godoc.org/github.com/hexdigest/gowrap?status.svg)](http://godoc.org/github.com/hexdigest/gowrap)
[![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/avelino/awesome-go#generation-and-generics)
[![Release](https://img.shields.io/github/release/hexdigest/gowrap.svg)](https://github.com/hexdigest/gowrap/releases/latest)

GoWrap is a command line tool that generates decorators for Go interface types using simple templates.
With GoWrap you can easily add metrics, tracing, fallbacks, pools, and many other features into your existing code in a few seconds.


## Demo

![demo](https://github.com/hexdigest/gowrap/blob/master/gowrap.gif)

## Installation
### CLI
```
go install github.com/hexdigest/gowrap/cmd/gowrap@latest
```
### As module
```
go get -u github.com/hexdigest/gowrap/cmd/gowrap
```

## Usage of gowrap

```
Usage: gowrap gen -p package -i interfaceName -t template -o output_file.go
  -g	don't put //go:generate instruction into the generated code
  -i string
    	the source interface name, i.e. "Reader"
  -o string
    	the output file name
  -p string
    	the source package import path, i.e. "io", "github.com/hexdigest/gowrap" or
    	a relative import path like "./generator"
  -t template
    	the template to use, it can be an HTTPS URL a local file or a
    	reference to one of the templates in the gowrap repository
  -v value
    	a key-value pair to parametrize the template,
    	arguments without an equal sign are treated as a bool values,
    	i.e. -v DecoratorName=MyDecorator -v disableChecks
```

This will generate an implementation of the io.Reader interface wrapped with prometheus metrics

```
  $ gowrap gen -p io -i Reader -t prometheus -o reader_with_metrics.go
```

This will generate a fallback decorator for the Connector interface that can be found in the ./connector subpackage:

```
  $ gowrap gen -p ./connector -i Connector -t fallback -o ./connector/with_metrics.go
```

Run `gowrap help` for more options

## Hosted templates

When you specify a template with the "-t" flag, gowrap will first search for and use the local file with this name.
If the file is not found, gowrap will look for the template [here](https://github.com/hexdigest/gowrap/tree/master/templates) and use it if found.

List of available templates:
  - [circuitbreaker](https://github.com/hexdigest/gowrap/tree/master/templates/circuitbreaker) stops executing methods of the wrapped interface after the specified number of consecutive errors and resumes execution after the specified delay
  - [fallback](https://github.com/hexdigest/gowrap/tree/master/templates/fallback) takes several implementations of the source interface and concurrently runs each implementation if the previous attempt didn't return the result in a specified period of time, it returns the first non-error result
  - [log](https://github.com/hexdigest/gowrap/tree/master/templates/log) instruments the source interface with logging using standard logger from the "log" package
  - [logrus](https://github.com/hexdigest/gowrap/tree/master/templates/logrus) instruments the source interface with logging using popular [sirupsen/logrus](https://github.com/sirupsen/logrus) logger
  - [opencensus](https://github.com/hexdigest/gowrap/tree/master/templates/opencensus) instruments the source interface with opencensus spans
  - [opentelemetry](https://github.com/hexdigest/gowrap/tree/master/templates/opentelemetry) instruments the source interface with opentelemetry spans
  - [opentracing](https://github.com/hexdigest/gowrap/tree/master/templates/opentracing) instruments the source interface with opentracing spans
  - [prometheus](https://github.com/hexdigest/gowrap/tree/master/templates/prometheus) instruments the source interface with prometheus metrics
  - [ratelimit](https://github.com/hexdigest/gowrap/tree/master/templates/ratelimit) instruments the source interface with RPS limit and concurrent calls limit
  - [retry](https://github.com/hexdigest/gowrap/tree/master/templates/retry) instruments the source interface with retries
  - [robinpool](https://github.com/hexdigest/gowrap/tree/master/templates/robinpool) puts several implementations of the source interface to the slice and for every method call it picks one implementation from the slice using the Round-robin algorithm
  - [syncpool](https://github.com/hexdigest/gowrap/tree/master/templates/syncpool) puts several implementations of the source interface to the sync.Pool and for every method call it gets one implementation from the pool and puts it back once finished
  - [timeout](https://github.com/hexdigest/gowrap/tree/master/templates/timeout) instruments each method that accepts context with configurable timeout
  - [validate](https://github.com/hexdigest/gowrap/tree/master/templates/validate) runs `func Validate() error` method on each argument if it's present
  - [twirp\_error](https://github.com/hexdigest/gowrap/tree/master/templates/twirp_error) inject request data into twirp.Error as metadata
  - [twirp\_validate](https://github.com/hexdigest/gowrap/tree/master/templates/twirp_validate) runs `func Validate() error` method on each argument if it's present and wraps returned error with twirp.Malformed error
  - [grpc\_validate](https://github.com/hexdigest/gowrap/tree/master/templates/grpc_validate) runs `func Validate() error` method on each argument if it's present and returns [InvalidArgument](https://github.com/grpc/grpc-go/blob/9d8d97a245af2d4bc743585418e1b4aebada0637/codes/codes.go#L49) error in case when validation failed
  - [elastic apm](https://github.com/hexdigest/gowrap/tree/master/templates/elasticapm) instruments the source interface with elastic apm spans

By default GoWrap places the `//go:generate` instruction into the generated code. 
This allows you to regenerate decorators' code just by typing `go generate ./...` when you change the source interface type declaration.
However if you used a remote template, the `//go:generate` instruction will contain the HTTPS URL of the template and therefore
you will need to have internet connection in order to regenerate decorators. In order to avoid this, you can copy templates from the GoWrap repository 
to local files and add them to your version control system:
```
$ gowrap template copy fallback templates/fallback
```

The above command will fetch the fallback template and copy it to the templates/fallback local file.
After template is copied, you can generate decorators using this local template:

```
$ gowrap gen -p io -i Reader -t templates/fallback reader_with_fallback.go
```

## Custom templates

You can always write your own template that will provide the desired functionality to your interfaces.
If you think that your template might be useful to others, please consider adding it to our [template repository](https://github.com/hexdigest/gowrap/tree/master/templates).

The structure of information passed to templates is documented with the [TemplateInputs](https://godoc.org/github.com/hexdigest/gowrap/generator#TemplateInputs) struct.

### Template Functions

In the templates, all functions provided by the [sprig](http://masterminds.github.io/sprig/) template library are available.

Additionally `gowrap` includes the following template functions:

- `up`: returns the input with all Unicode letters mapped to their upper case.
- `down`: returns the input with all Unicode letters mapped to their lower case.
- `upFirst`: returns the input with the first Unicode letter mapped to their upper case.
- `downFirst`: returns the input with the first Unicode letter mapped to their lower case.
- `replace`: returns the input with all occurences of the first argument replaced with the second argument.
- `snake`: returns the input in snake case representation.

## Become a patron

Here's my [Patreon page](https://www.patreon.com/hexdigest). Thank you!


GoWrap

Command line tool for generating interface definitions.

# interfaces [![GoDoc](https://godoc.org/github.com/rjeczalik/interfaces?status.png)](https://godoc.org/github.com/rjeczalik/interfaces) [![Build Status](https://img.shields.io/travis/rjeczalik/interfaces/master.svg)](https://travis-ci.org/rjeczalik/interfaces "linux_amd64") [![Build status](https://img.shields.io/appveyor/ci/rjeczalik/interfaces.svg)](https://ci.appveyor.com/project/rjeczalik/interfaces "windows_amd64")
Code generation tools for Go's interfaces.

Tools available in this repository:

- [cmd/interfacer](#cmdinterfacer-)
- [cmd/structer](#cmdstructer-)

### cmd/interfacer [![GoDoc](https://godoc.org/github.com/rjeczalik/interfaces/cmd/interfacer?status.png)](https://godoc.org/github.com/rjeczalik/interfaces/cmd/interfacer)

Generates an interface for a named type.

*Installation*
```bash
~ $ go install github.com/rjeczalik/interfaces/cmd/interfacer@latest
```

*Usage*

```bash
~ $ interfacer -help
```
```
Usage of interfacer:
  -all
        Include also unexported methods.
  -as string
        Generated interface name. (default "main.Interface")
  -for string
        Type to generate an interface for.
  -o string
        Output file. (default "-")
```

*Example*
- generate by manually
```bash
~ $ interfacer -for os.File -as mock.File
```
- generate by go generate
```go
//go:generate interfacer -for os.File -as mock.File -o file_iface.go
```
```bash
~ $ go generate  ./...
```
- output
```go
// Created by interfacer; DO NOT EDIT

package mock

import (
        "os"
)

// File is an interface generated for "os".File.
type File interface {
        Chdir() error
        Chmod(os.FileMode) error
        Chown(int, int) error
        Close() error
        Fd() uintptr
        Name() string
        Read([]byte) (int, error)
        ReadAt([]byte, int64) (int, error)
        Readdir(int) ([]os.FileInfo, error)
        Readdirnames(int) ([]string, error)
        Seek(int64, int) (int64, error)
        Stat() (os.FileInfo, error)
        Sync() error
        Truncate(int64) error
        Write([]byte) (int, error)
        WriteAt([]byte, int64) (int, error)
        WriteString(string) (int, error)
}
```

### cmd/structer [![GoDoc](https://godoc.org/github.com/rjeczalik/interfaces/cmd/structer?status.png)](https://godoc.org/github.com/rjeczalik/interfaces/cmd/structer)

Generates a struct for a formatted file. Currently supported formats are:

- CSV

*Installation*
```bash
~ $ go get github.com/rjeczalik/interfaces/cmd/structer
```

*Usage*

```bash
~ $ structer -help
```
```
Usage of structer:
  -as string
        Generated struct name. (default "main.Struct")
  -f string
        Input file. (default "-")
  -o string
        Output file. (default "-")
  -tag string
        Name for a struct tag to add to each field.
  -type string
        Type of the input, overwrites inferred from file name.
```

*Example*

```bash
~ $ head -2 aws-billing.csv         # first line is a CSV header, second - first line of values
```
```
"InvoiceID","PayerAccountId","LinkedAccountId","RecordType","RecordID","BillingPeriodStartDate","BillingPeriodEndDate","InvoiceDate"
"Estimated","123456","","PayerLineItem","5433212345","2016/01/01 00:00:00","2016/01/31 23:59:59","2016/01/21 19:19:06"
```
```bash
~ $ structer -f aws-billing.csv -tag json -as billing.Record
```
```go
// Created by structer; DO NOT EDIT

package billing

import (
        "strconv"
        "time"
)

// Record is a struct generated from "aws-billing.csv" file.
type Record struct {
        InvoiceID              string    `json:"invoiceID"`
        PayerAccountID         int64     `json:"payerAccountID"`
        LinkedAccountID        string    `json:"linkedAccountID"`
        RecordType             string    `json:"recordType"`
        RecordID               int64     `json:"recordID"`
        BillingPeriodStartDate time.Time `json:"billingPeriodStartDate"`
        BillingPeriodEndDate   time.Time `json:"billingPeriodEndDate"`
        InvoiceDate            time.Time `json:"invoiceDate"`
}

// MarshalCSV encodes r as a single CSV record.
func (r *Record) MarshalCSV() ([]string, error) {
        records := []string{
                r.InvoiceID,
                strconv.FormatInt(r.PayerAccountID, 10),
                r.LinkedAccountID,
                r.RecordType,
                strconv.FormatInt(r.RecordID, 10),
                time.Parse("2006/01/02 15:04:05", r.BillingPeriodStartDate),
                time.Parse("2006/01/02 15:04:05", r.BillingPeriodEndDate),
                time.Parse("2006/01/02 15:04:05", r.InvoiceDate),
        }
        return records, nil
}

// UnmarshalCSV decodes a single CSV record into r.
func (r *Record) UnmarshalCSV(record []string) error {
        if len(record) != 8 {
                return fmt.Errorf("invalud number fields: want 8, got %d", len(record))
        }
        r.InvoiceID = record[0]
        if record[1] != "" {
                if val, err := strconv.ParseInt(record[1], 10, 64); err == nil {
                        r.PayerAccountID = val
                } else {
                        return err
                }
        }
        r.LinkedAccountID = record[2]
        r.RecordType = record[3]
        if record[4] != "" {
                if val, err := strconv.ParseInt(record[4], 10, 64); err == nil {
                        r.RecordID = val
                } else {
                        return err
                }
        }
        if record[5] != "" {
                if val, err := time.Parse("2006/01/02 15:04:05", record[5]); err == nil {
                        r.BillingPeriodStartDate = val
                } else {
                        return err
                }
        }
        if record[6] != "" {
                if val, err := time.Parse("2006/01/02 15:04:05", record[6]); err == nil {
                        r.BillingPeriodEndDate = val
                } else {
                        return err
                }
        }
        if record[7] != "" {
                if val, err := time.Parse("2006/01/02 15:04:05", record[7]); err == nil {
                        r.InvoiceDate = val
                } else {
                        return err
                }
        }
        return nil
}
```


interfaces

Generate arbitrary Go code without templates.

jennifer

This package contains a set of utilities for generating Go boilerplate code for services based on OpenAPI 3.0 API definitions.

oapi-codegen

# a library to create type dynamically

[![Report](https://goreportcard.com/badge/github.com/xiaoxin01/typeregistry)](https://goreportcard.com/badge/github.com/xiaoxin01/typeregistry)
[![Build Status](https://travis-ci.org/xiaoxin01/typeregistry.svg?branch=master)](https://travis-ci.org/xiaoxin01/typeregistry)

## how to use

```go
// 1. define struct
type Student struct {
	Age  int
	Name string
}

// 2. add reflect type
key := AddType(new(Student))

// 3. create struct from registed key
student := Make(key)
```

## custom registed key

```go
var i interface{} = new(Student)

// use lowercase struct name as key
name := AddTypeWithKey(i, func(i interface{}) string {
	tpe := reflect.TypeOf(i).Elem()
	return strings.ToLower(tpe.Name())
})

student, ok := Create("student").(*Student)
```

## benchmark

```bash
go.exe test -benchmem -run=^$ supperxin/typeregistry -bench ^BenchmarkMake$

goos: windows
goarch: amd64
pkg: supperxin/typeregistry
BenchmarkMake-8   	 8823256	       138 ns/op	      64 B/op	       2 allocs/op
PASS
ok  	supperxin/typeregistry	1.551s
```

```bash
go.exe test -benchmem -run=^$ supperxin/typeregistry -bench ^BenchmarkCreateDirectly$

goos: windows
goarch: amd64
pkg: supperxin/typeregistry
BenchmarkCreateDirectly-8   	1000000000	         0.593 ns/op	       0 B/op	       0 allocs/op
PASS
ok  	supperxin/typeregistry	0.857s
```


The Best Go Libraries For Generators (9)