This library is deprecated with Go 1.18 which now has support for generics natively.
goreify implements a form of generics for go. It works by taking in a function
or type which uses dynamic functions and types and converts it into a function
or type which uses concrete (reified) types.
For example, this generic function:
func Sum(xs []generics.T1) generics.T1 {
var total generics.T1
for _, x := range xs {
total = generics.Add(total, x)
}
return total
}
Would be transformed into this reified version:
func Sum_int(xs []int) int {
var total int
for _, x := range xs {
total = total + x
}
return total
}
The original, generic version is completely valid and runnable Go code. It's just less efficient because it relies on reflection, and a bit clunky to work with because we can't use operators.
More examples can be found below.
go get github.com/badgerodon/goreify
goreify takes two parameters, the input type/function, and the reified types
you'd like to generate:
goreify path/to/your/package.YourFunction T1Type T2Type ...
For example:
goreify github.com/badgerodon/goreify/examples.Sum numeric
The special numeric pseudo-type is replaced with integers, floats and complex
types.
In practice you should use go:generate lines in your code:
//go:generate goreify github.com/badgerodon/goreify/examples.Sum numeric
Global functions:
//go:generate goreify github.com/badgerodon/goreify/examples.Diff int
// Diff finds the difference between two series
func Diff(xs, ys []generics.T1) []generics.T1 {
sz := len(xs)
if len(ys) < sz {
sz = len(ys)
}
zs := make([]generics.T1, sz)
for i := 0; i < sz; i++ {
zs[i] = generics.Subtract(xs[i], ys[i])
}
return zs
}
// yielding
func DiffInt(xs, ys []int) []int {
sz := len(xs)
if len(ys) < sz {
sz = len(ys)
}
zs := make([]int, sz)
for i := 0; i < sz; i++ {
zs[i] = xs[i] - ys[i]
}
return zs
}
Types:
//go:generate goreify github.com/badgerodon/goreify/examples.Pair int8 int16
// A Pair is a pair of values
type Pair struct {
// Fst is the first value
Fst generics.T1
// Snd is the second value
Snd generics.T2
}
// yielding
type PairInt8Int16 struct {
// Fst is the first value
Fst int8
// Snd is the second value
Snd int16
}
Methods on types:
func (l *List) Append(els ...generics.T1) {
l.elements = append(l.elements, els...)
}
// yielding
func (l *ListInt32) Append(els ...int32) {
l.elements = append(l.elements, els...)
}
Global functions using a type:
func Zip(xs []generics.T1, ys []generics.T2) []Pair {
mn := len(xs)
if mn > len(ys) {
mn = len(ys)
}
zs := make([]Pair, mn)
for i := 0; i < mn; i++ {
zs[i] = Pair{Fst: xs[i], Snd: ys[i]}
}
return zs
}
// yielding
func ZipInt8Int16(xs []int8, ys []int16) []PairInt8Int16 {
mn := len(xs)
if mn > len(ys) {
mn = len(ys)
}
zs := make([]Pair_int8_int16, mn)
for i := 0; i < mn; i++ {
zs[i] = PairInt8Int16{Fst: xs[i], Snd: ys[i]}
}
return zs
}
Functions to work with channels:
//go:generate goreify github.com/badgerodon/goreify/examples.Merge int
func Merge(srcs ...<-chan generics.T1) <-chan generics.T1 {
switch len(srcs) {
case 0:
return nil
case 1:
return srcs[0]
case 2:
dst := make(chan generics.T1)
go func() {
// merge until both channels are closed, then finally close the destination
defer close(dst)
c0, c1 := srcs[0], srcs[1]
for c0 != nil || c1 != nil {
select {
case m, ok := <-c0:
if !ok {
c0 = nil
continue
}
dst <- m
case m, ok := <-c1:
if !ok {
c1 = nil
continue
}
dst <- m
}
}
}()
return dst
default:
left, right := srcs[:len(srcs)/2], srcs[len(srcs)/2:]
return Merge(Merge(left...), Merge(right...))
}
}
// yielding
func MergeInt(srcs ...<-chan int) <-chan int {
switch len(srcs) {
case 0:
return nil
case 1:
return srcs[0]
case 2:
dst := make(chan int)
go func() {
defer close(dst)
c0, c1 := srcs[0], srcs[1]
for c0 != nil || c1 != nil {
select {
case m, ok := <-c0:
if !ok {
c0 = nil
continue
}
dst <- m
case m, ok := <-c1:
if !ok {
c1 = nil
continue
}
dst <- m
}
}
}()
return dst
default:
left, right := srcs[:len(srcs)/2], srcs[len(srcs)/2:]
return MergeInt(MergeInt(left...), MergeInt(right...))
}
}
Multiple dependent types: (for the input argument just put a , between the types)
//go:generate goreify github.com/badgerodon/goreify/examples.tree,treeNode int
type tree struct {
root *treeNode
}
type treeNode struct {
elem generics.T1
children []*treeNode
}
// yielding
type treeInt struct {
root *treeNodeInt
}
type treeNodeInt struct {
elem int
children []*treeNodeInt
}
This is useful for many data structures that involve recursive pointers.
I found gengen after implementing most of
this functionality. It follows a similar approach, though doesn't take it quite
as far.