changed examples to use square bracket syntax

Author: ardan-bkennedy

topics/go/generics/01-basic/generic.go2

@@ -72,9 +72,9 @@ func printReflect(v interface{}) {
 // implementations that we started with and is easier to read than the reflect
 // implementation. 
 
-func printGeneric(type T)(list []T) {
+func printGeneric[type T](slice []T) {
 	fmt.Print("Generic: ")
-	for _, v := range list {
+	for _, v := range slice {
 		fmt.Print(v, " ")
 	}
 	fmt.Print("\n")

topics/go/generics/02-named-type/generic.go2

@@ -43,9 +43,9 @@ func (v vectorInterface) push(value interface{}) vectorInterface {
 // accepts any value of type T determined at compile time. This value needs to
 // match the type used in the construction of the generics type.
 
-type vectorGeneric(type T) []T
+type vectorGeneric[type T] []T
 
-func (v vectorGeneric(T)) push(value T) vectorGeneric(T) {
+func (v vectorGeneric[T]) push(value T) vectorGeneric[T] {
 	v = append(v, value)
 	return v
 }
@@ -70,12 +70,12 @@ func main() {
 	vItf = vItf.push("B")
 	fmt.Println("vectorInterface:", vItf)
 
-	var vGenInt vectorGeneric(int)
+	var vGenInt vectorGeneric[int]
 	vGenInt = vGenInt.push(10)
 	vGenInt = vGenInt.push(20)
 	fmt.Println("vectorGeneric:", vGenInt)
 
-	var vGenStr vectorGeneric(string)
+	var vGenStr vectorGeneric[string]
 	vGenStr = vGenStr.push("A")
 	vGenStr = vGenStr.push("B")
 	fmt.Println("vectorGeneric:", vGenStr)

topics/go/generics/03-behavior-constraint/generic.go2

@@ -108,9 +108,9 @@ func stringifyReflect(v interface{}) []string {
 // applied to allow the compiler to know the value of type T passed will have
 // a String method.
 
-func stringifyGeneric(type T fmt.Stringer)(list []T) []string {
-    ret := make([]string, 0, len(list))
-    for _, value := range list {
+func stringifyGeneric[type T fmt.Stringer](slice []T) []string {
+    ret := make([]string, 0, len(slice))
+    for _, value := range slice {
         ret = append(ret, value.String())
     }
     return ret

topics/go/generics/04-type_constraint/generic.go2

@@ -13,7 +13,7 @@ type addOnly interface {
     type string, int, int8, int16, int32, int64, float64
 }
 
-func Add(type T addOnly)(v1 T, v2 T) T {
+func Add[type T addOnly](v1 T, v2 T) T {
     return v1 + v2
 }
 
@@ -24,7 +24,7 @@ func Add(type T addOnly)(v1 T, v2 T) T {
 // comparable constraint accepts as a type argument any comparable type. It
 // permits the use of == and != with values of that type parameter.
 
-func index(type T comparable)(list []T, find T) int {
+func index[type T comparable](list []T, find T) int {
 	for i, v := range list {
 		if v == find {
             return i
@@ -67,12 +67,12 @@ func (f food) match(v food) bool {
 // Note: The type list inside the interface is not needed for match to work.
 //       I'm trying to show how the type list and behavior can be combined.
 
-type matcher(type T) interface {
+type matcher[type T] interface {
     type person, food
     match(v T) bool
 }
 
-func match(type T matcher)(list []T, find T) int {
+func match[type T matcher](list []T, find T) int {
 	for i, v := range list {
 		if v.match(find) {
             return i

topics/go/generics/05-multi-type-params/generic.go2

@@ -11,7 +11,7 @@ import (
 // merged with the same index position of type V into a single string. This code
 // shows how the type list can contain more than just one generic type.
 
-func Print(type L interface{}, V fmt.Stringer)(labels []L, vals []V) {
+func Print[type L interface{}, V fmt.Stringer](labels []L, vals []V) {
 	for i, v := range vals {
 		fmt.Println(labels[i], v.String())
 	}

topics/go/generics/06-returns/generic.go2

@@ -106,7 +106,7 @@ type entities interface {
 	type User, Customer
 }
 
-func Insert(type T entities)(db *sql.DB, entity T, query string, args ...interface{}) (T, error) {
+func Insert[type T entities](db *sql.DB, entity T, query string, args ...interface{}) (T, error) {
 	var zero T
 
 	result, err := ExecuteQuery(query, args...)

topics/go/generics/07-link-list/generic.go2

@@ -21,20 +21,20 @@ type scalarOnly interface {
 	type int, int8, int16, int32, int64, string
 }
 
-type node(type T scalarOnly) struct {
+type node[type T scalarOnly] struct {
 	Data T
-	next *node(T)
-	prev *node(T)
+	next *node[T]
+	prev *node[T]
 }
 
-type list(type T scalarOnly) struct {
+type list[type T scalarOnly] struct {
 	Count int
-	first *node(T)
-	last  *node(T)
+	first *node[T]
+	last  *node[T]
 }
 
-func (l *list(T)) add(data T) *node(T) {
-	n := node(T) {
+func (l *list[T]) add(data T) *node[T] {
+	n := node[T] {
 		Data: data,
 		prev: l.last,
 	}
@@ -51,9 +51,9 @@ func (l *list(T)) add(data T) *node(T) {
 
 // =============================================================================
 
-type op(type T scalarOnly) func(n *node(T)) error
+type op[type T scalarOnly] func(n *node[T]) error
 
-func (l *list(T)) operate(f op(T)) error {
+func (l *list[T]) operate(f op[T]) error {
 	n := l.first
 	for n != nil {
 		if err := f(n); err != nil {
@@ -62,5 +62,4 @@ func (l *list(T)) operate(f op(T)) error {
 		n = n.next
 	}
 	return nil
-}
-
+}

topics/go/generics/08-hash-table/generic.go2

@@ -21,7 +21,7 @@ func main() {
 	hashFunc2 := func(key int, buckets int) int {
 		return key % buckets
 	}
-	table2 := New(int, string)(buckets, hashFunc2)
+	table2 := New(/*key*/ int, /*value*/ string)(buckets, hashFunc2)
 
 	words := []string{"foo", "bar", "baz"}
 	for i, word := range words {
@@ -40,28 +40,28 @@ func main() {
 
 // =============================================================================
 
-type hashFunc(type K) func(key K, buckets int) int
+type hashFunc[type K] func(key K, buckets int) int
 
-type keyValuePair(type K, V interface{}) struct {
+type keyValuePair[type K, V interface{}] struct {
 	Key   K
 	Value V
 }
 
-type Table(type K comparable, V interface{}) struct {
-    hashFunc hashFunc(K)
+type Table[type K comparable, V interface{}] struct {
+    hashFunc hashFunc[K]
 	buckets  int
-	table    [][]keyValuePair(K, V)
+	table    [][]keyValuePair[K, V]
 }
 
-func New(type K comparable, V interface{})(buckets int, hf hashFunc(K)) *Table(K, V) {
-	return &Table(K, V){
+func New[type K comparable, V interface{}](buckets int, hf hashFunc[K]) *Table[K, V] {
+	return &Table[K, V]{
 		hashFunc: hf,
         buckets:  buckets,
-		table:    make([][](keyValuePair(K, V)), buckets),
+		table:    make([][](keyValuePair[K, V]), buckets),
 	}
 }
 
-func (t *Table(K, V)) Insert(key K, value V) {
+func (t *Table[K, V]) Insert(key K, value V) {
 	bucket := t.hashFunc(key, t.buckets)
 	for idx, kvp := range t.table[bucket] {
 		if key == kvp.Key {
@@ -70,14 +70,14 @@ func (t *Table(K, V)) Insert(key K, value V) {
 		}
 	}
 
-	kvp := keyValuePair(K, V){
+	kvp := keyValuePair[K, V]{
 		Key:   key,
 		Value: value,
 	}
 	t.table[bucket] = append(t.table[bucket], kvp)
 }
 
-func (t *Table(K, V)) Get(key K) (V, bool) {
+func (t *Table[K, V]) Get(key K) (V, bool) {
     bucket := t.hashFunc(key, t.buckets)
     for idx, kvp := range t.table[bucket] {
         if key == kvp.Key {

topics/go/generics/09-slice-constraints/generic.go2

@@ -12,17 +12,17 @@ import (
 // Slice defines a constraint that the data is a slice of some type T to be
 // determined at compile time.
 
-type operateFunc(type T) func(t T) T
+type operateFunc[type T] func(t T) T
 
-type Slice(type T) interface {
+type Slice[type T] interface {
 	type []T
 }
 
 // When it is important that the slice being passed in is exactly the same
 // as the slice being returned, use a slice contraint. This ensures that the
 // result slice S is the same as the incoming slice S.
 
-func operate(type S Slice(T), T interface{})(slice S, fn operateFunc(T)) S {
+func operate[type S Slice[T], T interface{}](slice S, fn operateFunc[T]) S {
 	ret := make(S, len(slice))
 	for i, v := range slice {
 		ret[i] = fn(v)
@@ -37,7 +37,7 @@ func operate(type S Slice(T), T interface{})(slice S, fn operateFunc(T)) S {
 // case not a slice of Numbers, but a slice of integers. This is not the case
 // with operate function above.
 
-func operate2(type T)(slice []T, fn operateFunc(T)) []T {
+func operate2[type T](slice []T, fn operateFunc[T]) []T {
 	ret := make([]T, len(slice))
 	for i, v := range slice {
 		ret[i] = fn(v)

topics/go/generics/10-channels/generic.go2

@@ -13,7 +13,7 @@ import (
 // doWork will execute a work function in a goroutine and return a channel of
 // type Result back to the caller.
 
-func doWork(type Result)(ctx context.Context, work func(context.Context) Result) chan Result {
+func doWork[type Result](ctx context.Context, work func(context.Context) Result) chan Result {
 	ch := make(chan Result, 1)
 
 	go func() {
@@ -30,7 +30,7 @@ func doWork(type Result)(ctx context.Context, work func(context.Context) Result)
 // channel of type Input back to the caller. Once input is received by any
 // given goroutine, the work function is executed and the Result is displayed.
 
-func poolWork(type Input, Result)(wg *sync.WaitGroup, size int, work func(input Input) Result) chan Input {
+func poolWork[type Input, Result](wg *sync.WaitGroup, size int, work func(input Input) Result) chan Input {
 	ch := make(chan Input)
 
 	for i := 0; i < size; i++ {

topics/go/generics/11-swapping/generic.go2

@@ -36,7 +36,7 @@ func swapInterface(v1 interface{}, v2 interface{}) (interface{}, interface{}) {
 // implementation has the advanatge that concrete types are being used and only
 // data of the same type can be swapped. The caller doesn't require type assertions.
 
-func swapGeneric(type T)(v1 T, v2 T) (T, T) {
+func swapGeneric[type T](v1 T, v2 T) (T, T) {
 	v2, v1 = v1, v2
 	return v1, v2
 }

topics/go/generics/omissions/01-literal-functions/generic.go2

@@ -5,7 +5,7 @@ import "context"
 // Compiler Error: function type must have no type parameters
 
 func example1() {
-	go func(type T)(v T) {
+	go func[type T](v T) {
 
 		// Write some code here.
 
@@ -17,7 +17,7 @@ func example1() {
 // There's no need to make this literal function generic.
 
 func example2() {
-	f := func(type Result)(ctx context.Context) Result {
+	f := func[type Result](ctx context.Context) Result {
 
 		// Write some code here.
 

topics/go/generics/omissions/02-methods/generic.go2

@@ -6,7 +6,7 @@ type value struct {
 	s string
 }
 
-func (v value) Method(type Input, Result)(i Input) Result {
+func (v value) Method[type Input, Result](i Input) Result {
 
 	// Write some code here.
 }