Go Method Receiver Syntax Explained: Parentheses Before a Function Name

By the end of this page, you will understand that the extra parentheses before a Go function name define a receiver, which makes the function a method attached to a type. You will learn how value receivers and pointer receivers work, how to read declarations like func (s *Server) Start(), and when each style is used in real Go code.

In Go, a declaration like this:

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

is not an ordinary function. It is a method.

The part before the method name:

(h handler)

is called the receiver.

A receiver says:

• this method belongs to the type handler
• inside the method, that value will be available through the name h

So this method can be read as:

• ServeHTTP is a method on the type handler
• when called, the current handler value is referred to as h

Similarly:

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

means:

Think of a Go type as a tool, and a method as an action that tool knows how to perform.

• the type is the object
• the receiver is the label for "this object"
• the method is the action attached to it

For example, imagine a Car type.

func (c Car) Drive() {
    // ...
}

You can read this as:

• "A Car has a Drive behavior"
• inside the method, c means "this car"

So the receiver is similar to saying this instance.

If you have seen other languages, it is a bit like:

• this in Java or C#
• self in Python

Go just writes it explicitly in the method declaration:

func (c Car) Drive()

instead of hiding it behind a keyword.

A pointer receiver is like saying:

• "work with the real car itself"

A value receiver is like saying:

Basic syntax

Regular function

func add(a int, b int) int {
    return a + b
}

This is a normal function. It is not attached to any type.

Method with a value receiver

type Counter struct {
    Value int
}

func (c Counter) Display() int {
    return c.Value
}

Display is a method on Counter.

• receiver name: c
• receiver type: Counter

Call it like this:

counter := Counter{Value: 5}
fmt.Println(counter.Display())

Method with a pointer receiver

type Counter  {
    Value 
}

 Increment() {
    c.Value++
}

Consider this example:

package main

import "fmt"

type Counter struct {
    Value int
}

func (c *Counter) Increment() {
    c.Value++
}

func main() {
    counter := Counter{Value: 10}
    counter.Increment()
    fmt.Println(counter.Value)
}

Step by step

1. Define a type

type Counter struct {
    Value int
}

This creates a struct type named Counter.

2. Define a method on that type

func (c *Counter) Increment() {
    c.Value++
}

This says:

• Increment is a method on *Counter
• c points to the Counter value that called the method

Methods with receivers are used throughout Go code.

HTTP handlers

A common real example is:

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

This lets a type satisfy the http.Handler interface.

Use case:

• web servers
• middleware
• API routing

State-changing services

func (s *Server) Shutdown() error {
    // update internal state
    return nil
}

Pointer receivers are common for:

• servers
• database clients
• caches
• job queues

Domain models

func (u User) FullName() string {
    return u.FirstName + " " + u.LastName
}

Value receivers are often used for read-only behavior:

In real Go projects, receiver methods are used to organize behavior around types.

Common patterns

1. Guard clauses in methods

func (s *Server) Start() error {
    if s == nil {
        return fmt.Errorf("server is nil")
    }
    if s.running {
        return nil
    }
    s.running = true
    return nil
}

This is common when a method depends on internal state.

2. Validation methods

func (c Config) Validate() error {
    if c.Port <= 0 {
        return fmt.Errorf("invalid port")
    }
    return nil
}

This keeps validation logic close to the data it validates.

3. Mutating methods use pointer receivers

func (u *User) SetEmail(email string) {
    u.Email = email
}

1. Thinking the receiver is just a normal parameter

This is a very common first impression.

Broken mental model:

func (c Counter) Show()

This is not a function with a strange parameter before the name. It is a method declaration.

Remember:

• receiver syntax makes it a method
• methods are called with dot syntax

counter.Show()

2. Using a value receiver when you need to modify the original

Broken example:

type Counter struct {
    Value int
}

func (c Counter) Increment() {
    c.Value++
}

This only modifies a copy.

Fix:

func (c *Counter) Increment() {
    c.Value++
}

3. Mixing pointer and value receivers carelessly

Broken style:

func  Name()  {  u.name }
 SetName(name ) { u.name = name }

Function vs method

Function example

func add(a int, b int) int {
    return a + b
}

Method example

func  Increment() {
    c.Value++
}

Receiver syntax

func (name Type) MethodName(params) returnType {
    // ...
}

Examples

Value receiver

func (u User) FullName() string {
    return u.FirstName + " " + u.LastName
}

Pointer receiver

func (u *User) SetName(name string) {
    u.Name = name
}

How to read it

func (s *Server) Start() error

Read as:

• Start is a method
• receiver variable: s
• receiver type: *Server
• return type: error

Rules of thumb

What is the thing in parentheses before a function name in Go?

It is the receiver. It makes the declaration a method attached to a type.

Is (h handler) a function parameter?

No. It is not a regular parameter. It is receiver syntax used for methods.

What does *GracefulServer mean in the receiver?

It means the method has a pointer receiver, so it works with a pointer to GracefulServer and can modify the original value.

What is the difference between (c Counter) and (c *Counter)?

(c Counter) gets a copy of the value. (c *Counter) gets a pointer to the original value.

When should I use a pointer receiver in Go?

Use one when the method changes the struct, when the struct is large, or when you want consistent behavior across methods.

Are methods just functions in Go?

A method is a special kind of function that is attached to a type through a receiver.

Why does ServeHTTP often use a receiver?

Because Go's HTTP system uses interfaces, and a type can satisfy http.Handler by implementing the ServeHTTP method.

• Functions in Go — useful for understanding how methods differ from ordinary functions.
• Methods in Go — directly related because receiver syntax is what defines a method.
• Pointers in Go — important for understanding pointer receivers like *GracefulServer.
• Structs in Go — many methods are defined on struct types.
• Interfaces in Go — methods determine whether a type satisfies an interface.
• Method sets in Go — helpful for understanding how value and pointer receivers affect interface implementation.
• Go HTTP handlers — a practical example of receiver methods in everyday Go code.