Variable types

February 8, 2023


The static type (or just type) of a variable is the type given in its declaration, the type provided in the new call or composite literal, or the type of an element of a structured variable.

And here we are at one of the core features of Go, it’s static type system.

Each variable has a specific static type, which is typically provided in the variable definition, although there are a few cases where the type can be inferred.

Let’s look at some explicit examples:

var x int        // x is of type `int`, and is is initialized to the zero value for int
var y int = 123  // y is of type `int`, and initialized to the value 123
var z = int(123) // Alternative form of previous line

And a few examples of inferred types:

type Person struct {
	ID   int
	Name string

var p = Person{ID: 123, Name: "Bob"} // p is of type Person, the type of the
                                     // composite literal

var name = p.Name // name is of type string, inferred from the referenced
                  // structured element, Person.Name

A couple of other examples, not directly called out in this part of the spec, where the type can be inferred:

func foo() int { return 3 }

var x = foo() // x is of type int, as that is the type returned by foo()
const x = 123

y = x // y is of type `int`, the default type of an integer constant literal.

Quotes from The Go Programming Language Specification, Version of January 19, 2023

Share this

Related Content

Empty structs

We finally we have enough knowledge for the EBNF format not to seem completely foreign, so let’s jump back and take a look at that, with the examples provided in the spec… Struct types … StructType = "struct" "{" { FieldDecl ";" } "}" . FieldDecl = (IdentifierList Type | EmbeddedField) [ Tag ] . EmbeddedField = [ "*" ] TypeName [ TypeArgs ] . Tag = string_lit . // An empty struct.

Struct tags

Struct types … A field declaration may be followed by an optional string literal tag, which becomes an attribute for all the fields in the corresponding field declaration. An empty tag string is equivalent to an absent tag. The tags are made visible through a reflection interface and take part in type identity for structs but are otherwise ignored. struct { x, y float64 "" // an empty tag string is like an absent tag name string "any string is permitted as a tag" _ [4]byte "ceci n'est pas un champ de structure" } // A struct corresponding to a TimeStamp protocol buffer.

Struct method promotion

Yesterday we saw an example of struct field promotion. But methods (which we haven’t really discussed yet) can also be promoted. Struct types … Given a struct type S and a named type T, promoted methods are included in the method set of the struct as follows: If S contains an embedded field T, the method sets of S and *S both include promoted methods with receiver T. The method set of *S also includes promoted methods with receiver *T.