Question: I do not see where `s` is defined. Guru will not tell me. All I get is "no object for identifier" but it knows about the `k` right beside it. Here is a snippet that is typical of the linked code:

```
func getIndexAndRemainder(k uint64) (uint64, uint64) {
    return k / s, k % s
}

```

The one letter variable name definitely makes it harder to grep around for. I have looked for the usual suspects: `var s uint64`, `s := ...`, and nothing. Clearly it needs to be a global value defined somewhere.

This leaves me with two questions:

1. Where is `s` coming from?
2. How would I find it without asking here?

EDIT:
For others who stumble on this.

Guru failed me because I did not checkout the source for the package under a proper Go workspace by placing the git clone under /some/path/src and setting the `GOPATH` to /some/path. So while I thought `GOPATH=. guru definition s` would work, the `GOPATH` was ignored. guru could find `k` because it is in the file but it did not know how to look in other files.

My grep failed cause `const` uses a simple `=` not a `:=`. I will remember this when grepping in the future.

Answer: 
It is defined in `go-datastructures/bitarray/block.go`:

```
// s denotes the size of any element in the block array.
// For a block of uint64, s will be equal to 64
// For a block of uint32, s will be equal to 32
// and so on...
const s = uint64(unsafe.Sizeof(block(0)) * 8)

```

As the variable `s` was not defined in the function, and it was not prefixed by a package name or alias, it had to be a global (variable or constant) of the `bitarray` package.

Once that was known, I went through every file in the folder `go-datastructures/bitarray` that was not suffixed with `_test` and I looked for a top-level declaration for `s`.
It's defined in [go-datastructures/bitarray/block.go, line #33](https://github.com/Workiva/go-datastructures/blob/master/bitarray/block.go#L33):

```
const s = uint64(unsafe.Sizeof(block(0)) * 8)

```

"Modern" IDEs with Go support usually have the ability to go to the definition of a symbol / identifier your cursor is at or what you click on. For example in [Atom](https://atom.io/) with the [Go-plus](https://atom.io/packages/go-plus) plugin you can go to the definition by holding down the `CTRL` key while clicking.

These IDEs use the [godef](https://github.com/rogpeppe/godef) open source tool to find the definition source file and line, you may also use it directly. You can find the godef documentation here: <https://godoc.org/github.com/rogpeppe/godef>

Another tool, [guru](https://godoc.org/golang.org/x/tools/cmd/guru) is also capable of tracking the definition of it. Both guru and godef works in Atom, and were able to jump to block.go, to the definition of `s`. But it's much easier to use an "armored" IDE and just do a simple click.

Also note that the success of using `grep` and patterns is limited, as variable and constant declarations can be grouped, and the following are also valid declarations:

```
var (
    longer = 3
    s      = uint64(3)
)

```

Or:

```
var (
    s      = someExpression
    longer = 3
)

```

Or:

```
const (
    p = uint64(iota)
    s
    x
)

```