Function declaration syntax: things in parenthesis before function name

350
votes

I'm sorry I couldn't be more specific in the question title, but I was reading some Go code and I encountered function declarations of this form:

func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    ...
}

from https://github.com/mattermost/platform/blob/master/api/context.go

func (s *GracefulServer) BlockingClose() bool {
    ...
}

from https://github.com/braintree/manners/blob/master/server.go

What does the (h handler) and the (s *GracefulServer) between parenthesis mean? What does the entire function declaration mean, taking into account the meaning of the things between parenthesis?

Edit

This is not a duplicate of Whats the difference of functions and methods in Go? : this question came to me because I didn't know what the things in parenthesis before the function name were, not because I wondered what was the difference between functions and methods... if I knew that this declaration was a method I wouldn't have had this question in the first place. If someone has the same doubt as me one day, I don't believe she will go searching for "golang methods" because she doesn't know that this is the case. It would be like wondering what the letter "sigma" means before a mathematical expression (not knowing it means summation) and someone says it's a duplicate of what's the difference between summation and some other thing.

Also, the short answer to this question ("it's a receiver") is no answer to "what's the difference between functions and methods".

3
go
@Volker then put a disclaimer saying that the Go people on stackoverflow only answers questions that are not on the Tour of Go. In the Haskell community, people can ask questions like How can I get nth element from the list in Haskell?, which is in the Introduction on Learn you a Haskell for Great Good and get their questions answered without a fuss made about it. – Marcus Vinícius Monteiro
When I had this question, I first went to the Go Tour. I checked all the "Function" titles and none of the examples covered this. tour.golang.org/basics/4 tour.golang.org/basics/5 If you don't know to expand Methods and interfaces, you won't see the "Methods are functions" title. This question a valid and great for Google indexing. The duplicate flag zealots need to lighten up. – Bruno Bronosky
Thanks for not being specific in your question, because it was enough to help me find the answer! – David K
You asked exactly what I searched for, its a valid question. Thank you. I read all kind of function definition and no one explained this. I still tried writing my nube question and found this. – Ajak6

3 Answers

270
votes

This is called the 'receiver'. In the first case (h handler) it is a value type, in the second (s *GracefulServer) it is a pointer. The way this works in Go may vary a bit from some other languages. The receiving type, however, works more or less like a class in most object-oriented programming. It is the thing you call the method from, much like if I put some method A inside some class Person then I would need an instance of type Person in order to call A (assuming it's an instance method and not static!).

One gotcha here is that the receiver gets pushed onto the call stack like other arguments so if the receiver is a value type, like in the case of handler then you will be working on a copy of the thing you called the method from meaning something like h.Name = "Evan" would not persist after you return to the calling scope. For this reason, anything that expects to change the state of the receiver needs to use a pointer or return the modified value (gives more of an immutable type paradigm if you're looking for that).

Here's the relevant section from the spec; https://golang.org/ref/spec#Method_sets

123
votes

It means ServeHTTP is not a standalone function. The parenthesis before the function name is the Go way of defining the object on which these functions will operate. So, essentially ServeHTTP is a method of type handler and can be invoked using any object, say h, of type handler.

h.ServeHTTP(w, r)

They are also called receivers. There are two ways of defining them. If you want to modify the receiver use a pointer like:

func (s *MyStruct) pointerMethod() { } // method on pointer

If you dont need to modify the receiver you can define the receiver as a value like:

func (s MyStruct)  valueMethod()   { } // method on value

This example from Go playground demonstrates the concept.

package main

import "fmt"

type Mutatable struct {
    a int
    b int
}

func (m Mutatable) StayTheSame() {
    m.a = 5
    m.b = 7
}

func (m *Mutatable) Mutate() {
    m.a = 5
    m.b = 7
}

func main() {
    m := &Mutatable{0, 0}
    fmt.Println(m)
    m.StayTheSame()
    fmt.Println(m)
    m.Mutate()
    fmt.Println(m)

The output of the above program is :

&{0 0}
&{0 0}
&{5 7}
2
votes

If you are familiar with c# extension methods,

a go method (a function with a special receiver argument) e.g.

func (v Vertex) Abs() float64

is similar to c# extension method

static float Abs( this Vertex v);

The differences between value types and pointers are described in evanmcdonnal’s answer