GO language decorator programming

Before wrote a “Python decorator, functional programming, this model can easily get on some function fitting to some other function, can make your code more simple, also can make some small” functional “code reusability is higher, make the function in the code can be freely assembled like lego. Therefore, I have always been interested in the programming mode of decoration. Here I will write an article about Go language.

Those of you who read the Python decorator article know that this is a form of functional programming — wrapping a higher-order function around it. Say more, about functional programming, you can see before I wrote an article “functional programming”, this article mainly, through from procedural programming way of thinking to functional programming way of thinking, to drive more people to play functional programming, so if you want to know about the functional programming, you can walk to read first. So, Go’s modifier programming pattern is actually the pattern of functional programming.

Note, however, that Go doesn’t have much sugar and is a strongly typed, static, virtual-free language, so you can’t do decorator code as elegant as Java and Python. Of course, I may be the uneducated, if you know of more, please do let me know. Thanks in advance.

A simple example

Let’s start with an example:

We can see that we are using a higher-order decorator() that passes in Hello() and returns an anonymous function that calls Hello() as well as its own code.

This is similar to Python, except that, sadly, Go doesn’t support @decorator syntactic sugar like Python does. So, it’s kind of ugly to call. Of course, if you want to make your code easier to read, you can do this:

Let’s look at another example of calculating the running time:

A few things to say about the above code:

1) There are two Sum functions, Sum1() is a simple loop, and Sum2() uses a data formula. (Note: start and end can have negative numbers)

2) The code uses the Go language reflection machine to get the function name.

3) The modifier function is timedSumFunc()

Output after running:

Call waiting welfare

1. Recently sorted out 20G resources, including product/operation/test/programmer/market, etc., and Internet practitioners [necessary skills for work, professional books on the industry, precious books on interview questions, etc.]. Access:

• Scan the code of wechat to follow the public account “Atypical Internet”, forward the article to the moments of friends, and send the screenshots to the background of the public account to obtain dry goods resources links;

2. Internet Communication Group:

• Pay attention to the public account “atypical Internet”, in the background of the public account reply “into the group”, network sharing, communication;

An example related to HTTP

Let’s look at a related example of handling an HTTP request.

Let’s start with a simple HTTP Server code.

The Decorator pattern is used in the code above. The WithServerHeader() function is a Decorator that passes in an HTTP.handlerfunc and returns an overwritten version. The above example is still relatively simple, adding a Response Header with WithServerHeader().

So, we can write several of these functions. Some write HTTP response headers, some write authentication cookies, some check authentication cookies, some log…

Pipeline for multiple modifiers

In practice, the need to layer functions on top of each other doesn’t look very good, and the code will look ugly if you need more decorators. Well, we can refactor that.

To refactor, we need to write a utility function that iterates through and calls each decorator:

Then, we can use it like this.

Isn’t this code a little more readable? The pipeline function comes out.

Modifiers for generic types

However, for Go the decorator pattern, there is a small problem – as if unable to do a generic, like the above the calculation function of time, the code needs to be modified function coupling interface type, can’t do is very general, if it doesn’t solve, so, the decorator pattern is a bit bad to use.

Because Unlike Python and Java, Python is a dynamic language, and Java has a language virtual machine, so they can do a lot of kinky things, whereas Go is a static language, which means that its types need to be fixed at compile time, otherwise it won’t compile. However, the largest generics supported by the Go language are interface{} and the simpler Reflection mechanism, which should still work.

Without further ado, here is a more general modifier I wrote using reflection (I have removed the error determination code for ease of reading)

The above code invokes reflect.makefunc () to create a new function where targetfunc.call (in) calls the decorated function. I recommend The official article “The Laws of Reflection” for The Go language, which I won’t Go into here.

The Decorator() above takes two arguments,

• The first one is the output parameterdecoPtr, is the modified function
• The second is the input parameterfn, is the function that needs to be decorated

Isn’t that a little silly? It is. However, this is the best code I could write personally in the Go language. If you know more elegant, please do let me know!

Ok, let’s see how it works. First suppose we have two functions that need to be decorated:

Then, we can do this:

You’ll notice how silly it feels to use a Decorator() and declare a function signature first. It’s not generic at all, is it?

Well. If you don’t want to declare a function signature, you can

Well, it doesn’t look pretty, but it works. Go doesn’t seem to have the same features as Java or Python right now, so we can only ask for more sugar!