3 min read
Label scopes
Last Monday we had a great time on the Boldly Go: Live livestream, as we built a simple linter by following an online tutorial. For the next live stream, I intend to build a real linter, to solve some real world problems on one of my open source projects. Normally, I would do that today, but my office is undergoing some serious rennovation (three walls and the ceiling are being removed and replaced), so I don’t have anywhere to record from.
3 min read
Scope of the package clause
If you’ve written any code in Go, you’ve seen the package clause: package main So what is the scope of this clause? Declarations and scope … The package clause is not a declaration; the package name does not appear in any scope. Its purpose is to identify the files belonging to the same package and to specify the default package name for import declarations. If it has no scope, why is it needed?
1 min read
Shadowing
The concept of shadowing should be familiar to many readers. But here we see how Go defines it… Declarations and scope … An identifier declared in a block may be redeclared in an inner block. While the identifier of the inner declaration is in scope, it denotes the entity declared by the inner declaration. Notice that shadowing is not limited to variables. You can shadow function names, types, constants, or variables.
1 min read
Scope within functions
Today we’re rounding out the list of scoping rules, with two more: Declarations and scope … The scope of a constant or variable identifier declared inside a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl for short variable declarations) and ends at the end of the innermost containing block. The scope of a type identifier declared inside a function begins at the identifier in the TypeSpec and ends at the end of the innermost containing block.
Subscribe to Boldly Go: Daily
Every day I'll send you advice to improve your understanding of Go. Don't miss out! I will respect your inbox, and honor my privacy policy.
Unsure? Browse the archive.
1 min read
Scope of type parameters
If you missed it, we had a great Boldly Go: Live livestream yesterday. I built a basic linter from scratch. It was easier than I expected, and we all learned a few things. It’s not too late to catch the replay if you’re interested! Type parameters are what power generics, and they have two specific scoping rules: Declarations and scope … The scope of an identifier denoting a type parameter of a function or declared by a method receiver begins after the name of the function and ends at the end of the function body.
1 min read
Scope of the function block
Join me later today for my second Boldly Go Live stream! Declarations and scope … The scope of an identifier denoting a method receiver, function parameter, or result variable is the function body. This is pretty intuitive. When declaring a function or method: func sum(a, b int) (result int) { /* ... */ } func (a Animal) Speak() { /* ... */ } The scope of any variables mentioned in the function signature (method receiver, function parameter, or result variables), are the function body.
9 min watch
Constants can't overflow, and what that means for you
Constants in Go don't overflow, by definition. Why? And what does this mean?
1 min read
Scope of imported package names
Continuing our examination of scope… Declarations and scope … The scope of the package name of an imported package is the file block of the file containing the import declaration. The only thing that goes in the file block are imported package names. This is why you must repeat an import statement for every file that uses a symbol from the imported package. So for example, given two files in the same package:
1 min read
The universe and package blocks
Let’s now dive into the specific scoping rules in Go. There are 8 rules here, and we’ll take one or two per day… Declarations and scope … Go is lexically scoped using blocks: The scope of a predeclared identifier is the universe block. The “universe block”, which encompasses all Go source text, only contains the predeclared identifiers defined in the specification. Specifically, these identifiers are the names of predeclared types, the constants true, false, and iota, the zero value nil, and the built-in functions.
2 min read
Scope, defined
Declarations and scope … The scope of a declared identifier is the extent of source text in which the identifier denotes the specified constant, type, variable, function, label, or package. This definition isn’t necessarily specific to Go. Most modern languages have a concept of scope that’s pretty similar. What mainly differs between languages is the rules for where sopes begin and end, or some essoteric features like hoisting in JavaScript.
2 min read
Where declarations are allowed
First, a big thanks to everyone who showed up for yesterday’s first Boldly Go Live stream. We had some audio problems, which I promise to fix before the next one. But otherwise it was a success, with some great discussion. You can catch the replay if you missed it. Here we are at the formal description of declaration syntax. Declarations and scope … Declaration = ConstDecl | TypeDecl | VarDecl .