Skip to content
Go to file

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

fungen Build Status

fungen is a tool that can be used with go generate to automate the creation of list like types and methods like Map, Filter, Reduce, etc on these types.

This allows you to use constructs like the following on lists of any types:

myList.Map(func(t type1) type1 {


}).Filter(func(t type1) bool {


}).Take(3).Reduce(initialValue type1, func (prev type1, current type1) type1 {



The Map and Filter methods have parallel counterparts PMap and PFilter which can be used to parallelize time consuming operations.

Note: This tool uses standard golang constructs to make this functionality available on any type - standard and custom. Interfaces have NOT been used.


While the for loop in Go is quite nice, it still involves some boilerplate code. In my particular case, I realized that I could eliminate a majority of that code by using the following constructs:

  • Map (apply a function to each member of a list and return the resulting list - of either the same type or a different type)
  • PMap (parallel map)
  • Filter (apply a function to each member of a list to retrieve only the ones that satisfy some criteria)
  • PFilter (parallel filter)
  • FilterMap (applies the filter(s) and map to the list members in a single loop and returns the resulting list containing members of the mapped type)
  • PFilterMap (parallel FilterMap)
  • Reduce (perform aggregation functions on a list)
  • ReduceRight
  • Each (execute any function on each element of a list)
  • EachI
  • Take (create a new list containing only the first n elements of another list)
  • TakeWhile (take the first elements that satisfy a particular criteria)
  • Drop (create a new list by excluding the first n elements of another list)
  • DropWhile (exclude the first elements that satisfy a particular criteria)
  • All (returns true if all the members of the list satisfy a function or if the list is empty)
  • Any (returns true if at least one member of the list satisfies a function)

How to Use

Assuming you have installed fungen (see below), you can start by including the comment in your file for go generate to process. Let's assume we want to use the above methods with a list of strings (type []string).

Add the following comment in your source code:

//go:generate fungen -types string

Now run the go generate command in the same directory where this source file is located. This will generate a file named fungen_auto.go in this directory. This file will contain the type and method definitions that you'll need.

If you take a look at the file, you'll see that a new type has been created:

type stringList []string

If you now use this type (stringList) in place of []string, you'll be able to use all the above mentioned methods on that list of string.

words := stringList{"calculator", "skip", "grape", "obtainable", "inexpensive", "panoramic", "powerful"}

wordsWithLengthLessThan7 := words.Filter(func(w string) bool {
  return len(w) < 7  
// wordsWithLengthLessThan7 = [skip grape]


go install

Code Generation

The complete command to generate the code:

fungen -package PackageName -types comma,Separated,Types,With,Optional:Opt,short:Sh,names:n

Use from source code:

//go:generate fungen -types string,int

followed by

go generate

on the command line, in the directory where you wish the generated file to be stored.

Use From the command line:

fungen -types string,int

This tool will generate as a file named fungen_auto.go.

Explanation of Options

-package PackageName

The -package parameter is optional. If specified, it will generate the code file by using package PackageName at the top. If omitted, it will generate the code file by using package main at the top.

-types comma,Separated,Types,With,Optional:Opt,short:Sh,names:n

The -types parameter takes a comma separated list of types for which the list type and methods on this type should be generated. eg: (int,string,uint,customType)

Each of the comma separated values can themselves optionally be a colon separated value. If this is the case, the first part (before the colon) should be a valid type name (built in or custom) and the second is the name used in the names of the methods.

-filename filename.go

Filename for generated package (default "fungen_auto.go"). The -filename parameter is optional.

-methods Map,Filter

Comma separated list of methods to generate. By default generate all methods.

Valid methods is: Map,PMap,Filter,PFilter,Reduce,ReduceRight,Each,EachI,Take,TakeWhile,Drop,DropWhile,All,Any,FilterMap,PFilterMap

Example 1

If -types int,string is used, the types generated will be:

type intList []int
type stringList []string

The following methods will be available on both these types:


Additionally, the intList type will have the following methods:


And the stringList type will have the following methods:


Example 2

If -types int:I,string:Str is used, the names of the common set of methods generated will be the same as above. However, the types and the additional methods generated will have different names.

The types will be named as follows:

type IList []int
type StrList []string

The IList type will have the following methods:


And the StrList type will have the following methods:


Feedback, critique and contributions are all welcome.


Replace boilerplate code with functional patterns using 'go generate'





No releases published


No packages published


You can’t perform that action at this time.