Associated Types

[jamesgarfield]

Related Types

(renamed from associated types because apparently haskell has that already)

A Related Type is a type defined in generic code that does not need a matching type from the specification source because it is can be concretely implemented by the implementation of the other types in the generic code. A Related Type would also require an _ to be part of the name somewhere in order to avoid collisions with other implementations. The _ gets replaced with some inferred identifier.

In the following code _Sorter would be considered an associated type. By solving for Slice and T, _Sorter can be fully rewritten by selecting an identifier to replace the _ with

type T interface{}
type Slice []T
func (s Slice) Len() int { return len(s)}
func (s Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

type _Sorter struct {
    Slice
    LessFunc func(i, j *T) bool
}

func (s Slice) Less(i, j int) bool {
    return s.LessFunc(s.Slice[i], s.Slice[j])
}

Given these types

type User struct {
    Name string
    Age  int
}
type Users []*User

The expected implementation of _Sorter would be

type UsersSorter struct {
    Users
    LessFunc func(i, j *User) bool
}

func (s UsersSorter) Less(i, j int) bool {
    return s.LessFunc(s.Users[i], s.Users[j])
}

This effectively eliminates the need for multiple sorting types, and allows for concise adhoc sorting

sort.Sort(UsersSorter{users, func(a, b *User) bool { return a.Age < b.Age }})

or even

func (s Users) Sort(fn func(*User, *User) bool) {
    sort.Sort(UsersSorter{s, fn})
}
// time passes
users.Sort(func(a, b *User) bool { return a.Age < b.Age })

Possible _ replacement inference rules

• First encountered specification type within the associated type (Users in the example)
• Least complex type in the associated type (User in the example)
• Most complex type in the associated type (Users in the example)