gobyexample | Example site is built by extracting code

You can use time.Truncate for rounding the time to the full day:

You can't abort a running function. The function has to support abortion, idiomatically through a context.Context or a channel. If you want to support timeout or abortion, you have to change / refactor your function. And the function itself has to support this, e.g. it has to monitor the context.Context and return early if cancellation was requested. For details and example, see Terminating function execution if a context is cancelled

See related:

cancel a blocking operation in Go

Cancelling user specific goroutines

No you can't, because the types are different. One has to apply the ... operator to a slice to pass it as a variadic input .

You need to understand what a pointer is in order to understand what's going on here. A pointer contains the address of another variable.

The two types of receiver are different in that one (pointer) expects an address and the other (value) expects not-an-address.

Now, to answer your first question: "Why are the results the same?"

First, rp is a pointer to r. Meaning what is contained in rp is the address of r. So both r and rp eventually refer to the same struct (r directly contains it and the address in rp points to it). So in the end it is the same struct.

Also, the reason r and rp can both be used with pointer and value receivers is this: Go is automatically getting what's at the address contained in rp when calling perim() (which as a value receiver requires not-an-address) and it is automatically getting the address of r for passing when calling area() (which as a pointer receiver requires an address).

To answer your second question: "What does this mean ...?"

To understand this, you need to know that all functions in Go use pass-by-value. That means that when you pass a struct with many fields to a function, the entire struct with all its fields will be copied into a new variable to be used inside the function. However, if you pass a pointer (an address of the struct with many fields) only the address is copied into a variable to be used inside the function - which is a lot less copying.

fmt.Println(w) does not write into w. It writes w to the standard output. And since nobody writes into w, an empty response document will be sent back to the HTTP client.

To write into w, call its Write() method like this:

You don't need a select to do the thing you described:

A lot of what you're talking about is opinion-based, so I'm going to start with my own opinions.

In the C++ world, we expect RAII. If you want to get along well with other developers, you're both going to encounter it, and you're going to buck the standard if you decide to do something in a different fashion just because it's what you're accustomed to from Go.

Furthermore, C++ developers don't use FOPEN :-). The C++ standard library includes perfectly good RAII-enabled classes, and we use them. So having to implement RAII really means making proper choices of existing standard classes where possible or making sure your objects are RAII-compatible.

I pretty much never have to redesign my code to implement RAII. My choice of classes handles it automatically.

So while the code you've shown is interesting, it's actually more work than RAII. Every time you use FOPEN, you have to also remember to do your defer thing. Isn't it just so much easier to use std::ifstream or std::ofstream? Then it's already handled for you. (And this can be said about other times where your code would have to implement RAII on the spot. It's already done by picking the right classes.)

So, no, it's not neater and more intuitive, because you have to remember to do it. Pick the right classes, and you don't have to remember.

As for the #defines -- they're just there to make sure your variables have unique names and to shortcut the constructor of the defer class.

From https://blog.golang.org/playground

Like the file system, the playground's network stack is an in-process fake implemented by the syscall package. It permits playground projects to use the loopback interface (127.0.0.1). Requests to other hosts will fail.

So it's normal, your code is good but go playground can only connect to 127.0.0.1

Any() expects a function value of type func (string) bool, but strings.HasPrefix() has type func (string, string) bool. It can't be passed directly.

That's why you used a function literal in the first place: to pass a function value that has the proper type.

If you would have a named function with exactly this signature, you could pass it: