Shulou(Shulou.com)06/02 Report--

Editor to share with you the example analysis of generic programming in Go1.18, I believe that most people do not know much about it, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to know it!

Preface

After years of calling, the concise Go language finally ushered in generic programming in version 1.18. As a strongly typed language with a history of 14 years, it is hard to believe that it has only now begun to have a formal generics.

Previous Go generics

Although generics were not added until version 1.18, there was talk of adding generic design to Go in 2014. But it didn't come true due to various reasons. After that, the interface (interface) was proposed, which made generics shelved further. However, due to interface defects, the Go team eventually added generics to version 1.18. In fact, this version of generic design is very similar to interfaces at the language level (certainly different at the implementation level, with generics at compile time and interfaces at run time), and the differences between them will be mentioned later.

This article focuses on generics in the 1.18beta1 version, which may be changed later.

What is a generics?

In my opinion, it is very accurate to describe generics as a practical C++ template. When writing code, we often need to write a lot of repetitive logic, usually at this time we will use functions to encapsulate it. But because Go is a strongly typed language, you need to indicate the type before calling the function when defining and writing functions. Of course, if this repetitive logic requires only fixed types, this is sufficient, but many times we need different types to do similar logic, such as the GIF we just saw. This situation may be rare for the average developer, but it has become very common for some library developers.

Generic programming (generic programming) is a style or paradigm of programming language. Generics allow programmers to use types that are specified later when writing code in a strongly typed programming language and specify these types as parameters when instantiated. Various programming languages and their compilers and running environments have different support for generics. Ada, Delphi, Eiffel, Java, C #, F#, Swift and Visual Basic .NET are called generics; ML, Scala and Haskell are called parametric polymorphisms (parametric polymorphism); C++ and D are called templates. The 1994 edition of Design Patterns, which has an extensive influence, is called parameterized type (parameterized type).

Among them, C++ template should be the most perfect, not only support simple template replacement, but also deal with some simple logic, after constant iteration, has formed a programming way to generate code, so it is also called template metaprogramming (Template metaprogramming). Of course, because it is completely inconsistent with C++ programming, so the readability is very poor. In Go's generic design, Go does not support template metaprogramming in order to keep generics concise (heart plug, but also want to try to operate in Go).

Generics of Go

Next comes the introduction to the use of Go generics. Go supports generic functions and generic types.

Generic function

Let's start with the simplest generic function.

Func ink19FirstGen [T any] (t T) {fmt.Println (t)}

This is a very simple function that prints the input parameters using fmt.Println. Compared to the previous function, there are more [T any] parts, which is the parameter list of Go generics.

The parameter in the parameter list consists of two parts, the parameter name and the constraint, where T is the parameter and any is the constraint of the parameter. In terms of expression, it is similar to the consistent style of the Go language, with the name before the type.

In the GE language, interface interface is used as a type constraint, where any = interface {} is unlimited, but it is said to be unlimited rather than completely restricted. Since there are no methods defined in any, there is no way to call any method of t in the function.

A very important issue here is that compared to C++ 's template, Go parses functions when they are defined. So the method used in the function must appear in the interface of the constraint.

Type ink19Inf interface {Test ()} func ink19FirstGen [T ink19Inf] (t T) {t.Test ()}

Similar to ordinary parameters, the parameter type also supports simplification if it is the same constraint

Func ink19FirstGen [T, T2 ink19Inf] (t T, T2 [] T2) {t.Test ()} generic type

Similar to the template class in C++, Go also has generic types, and its definition is very simple.

Type ink19Vector [T any] [] T

The structure has more [T any] parts than the previous type definition, but the structure of this part is similar to that of generic functions.

For generic types, Go can also define related methods, such as:

Func (m * ink19Vector [T]) Push (v T) * ink19Vector [T] {* m = append (* m, v) return m}

In generic structures, structures can also define variables of their own types to form linked lists.

Type List [T1, T2 any] struct {next * List [T1, T2] T1 T1 T2}

PS: according to the proposal, the parameter list in the second line should be in the same order as in the definition to prevent infinite recursion. However, in the actual measurement of the 1.18beta1 version, the writing method with inconsistent order will not report an error.

Go does not support method generics for the time being.

Type set

Although most of the requirements can be met by restricting types through interfaces, there are still some requirements that cannot be met, such as operators. If we have a function, we can pass in any comparable parameter and return the smaller one. Naturally, we can write the following code:

Func whoismin [T any] (a, b T) T {if a < b {return a} return b}

However, unfortunately, because our constraint on T is any. So in fact, we can't do anything with an and b, and so is the comparison. So here, we get the wrong message.

Invalid operation: cannot compare a < b (operator < not defined on T)

In order to solve this problem, the concept of type set is proposed in the proposal.

For a type, it is thought that the type collection it represents is the collection that contains only this type, that is, for type M, the type collection it represents is {M}. For an interface, the corresponding set of types is infinite, and as long as a type satisfies all the method signatures of the interface, then the type belongs to the set of types of the interface. It is easy to understand that a collection of types is a collection of types that the identifier can represent.

Consider the operation of the collection, for the following example

Type ink19Inf1 interface {What1 ()} type ink19Inf2 interface {What2 ()} type ink19Inf3 interface {What1 () What2 ()}

Suppose that the type set of ink19Inf1 is A _ maxim ink19Inf2 and the type set of B _ Magi ink19Inf3 is C. Then it is easy to get Centra ⋂B. That is, C is the intersection of An and B. Of course, only intersection is not possible, and the implementation of union is described later.

To further illustrate the set of types, let's recall the definition of the interface. For the previous interface, there are two elements of the interface: method signatures and other interfaces.

Type ink19Inf1 interface {What ()} type ink19Inf2 interface {ink19Inf1 It ()}

For example, the first element in ink19Inf2 is other interfaces, and the second element is other signatures. But having these two elements alone is not enough for generic constraints. To this end, three other different elements have been added to the proposal, and it is important to note that if these additional three elements are added to an interface, the interface can no longer be used as a normal interface, but can only be used as a generic.

The first addition is the type element. Previous interfaces could not use types as interfaces, but they could be done as constraints. As an element, you provide a collection of types that contain only your own types as elements.

The second is the addition of approximate constraint elements, which are written by adding a ~ symbol before the type, such as

Type ink19Inf1 interface {~ int}

The meaning of this element is to provide a collection of all the underlying types of int for the interface. So the type modified by ~ should also be an underlying type, otherwise the set provided is an empty set, which doesn't make any sense. The specific differences can be seen in the following example.

Type ink19Inf3 interface {int} type ink19Inf4 interface {~ int} type MyInt int

First, we define two interfaces, the first of which uses the additional first element, so its collection of types contains only int. The other uses the second element, whose type collection contains all types with int as the underlying type. Then we define a MyInt type, which is a type with int as the underlying type. It is important to note that MyInt and int are two different types in Go. Finally, we write two methods to use the two interfaces as constraints.

Func ink19Print1 [T ink19Inf3] (t T) {fmt.Println (t)} func ink19Print2 [T ink19Inf4] (t T) {fmt.Println (t)} var data MyInt = 1ink19Print1 (data) / / error ink19Print2 (data)

The third element is the federation constraint. The method of use is as follows

Type ink19Inf5 interface {int | float32 | bool | ~ string | ink19Inf3}

The way to use it is very simple, which is to use the merged elements one by one. It is important to note that elements of federated constraints only support types, myopic constraints, and other interfaces that contain only the above three additional elements (that is, interfaces that contain method signatures are not supported).

Going back to the previous problem, you can solve the problem with the above tools when you need to use operators.

Throughout the go language, since operators are not supported, there are only a limited number of types that have operators (except = = and! =), such as int,float32,string and so on.

So for constraints that need to use the comparison operator, you can use one of the following constraint interfaces:

Type Ordered interface {~ int | ~ int8 | ~ int16 | ~ int32 | ~ uint | ~ uint | ~ uint16 | ~ uint32 | ~ uint64 | ~ uintptr | ~ float32 | ~ float64 | ~ string}

For ease of use, a constraints is provided in the Go standard library to provide relevant constraints.

As mentioned above, operators other than = = and! = can be achieved by enumerating all types. However, for these two operators, user-defined types also have these two operators, and there is no way to enumerate the implementation. The official approach is to complete the operation by using a built-in constraint comparable. For example,

Differences between func IsSame [T comparable] (a T, b T) bool {return a = = b} and interfaces

As I do not use much of the interface for Go, please correct in time if there are any deficiencies.

In terms of implementation methods, generics are compiled and interfaces are run-time

Constraints of operators can be implemented

The returned parameters can be of a specific type, while the interface can only return a fixed interface type

Generic constraints can have more operations than interfaces.

The above is all the content of the article "sample Analysis of generic programming in Go1.18". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.