Go

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.go

Registry names

go

Recorded symbols

functions · methods · interfaces · packages

Relationship types this analyzer constructs

12 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

12 constructed, 2 not constructed. All 2 absent types are recorded as ruled absent: the written reason and the corpus measurement behind each are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• Generics are declined for satisfaction: deciding whether Lattice[T] implements Lattice[U] needs type unification over instantiations, so both sides are skipped rather than compared as signature text.
• A bare call resolves only when this file declares the target, so a call into a sibling package arrives as a name. Under a dot import the file cannot say which names arrived from where, so those calls resolve leniently while bare value reads stay strict — the two channels are deliberately not symmetric.
• Go has no inheritance, so there is no extends in the class sense and no override edge at all. What looks like one is a struct embedding, recorded as a promotion of that type's methods.

Every line above was written against Go’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .go. Everything below is about where those files actually sit in a working repository.

• Interfaces are satisfied implicitly, so the type that owes a contract and the interface it owes it are almost always in different files.
• Struct embedding promotes methods without writing them, which is how a type satisfies an interface using fields it does not declare.
• A go f() or defer f() statement is still a call, and bb records the spawn and the cleanup as distinct patterns on the edge.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. Does this type satisfy that interface, counting the methods it embeds?
2. Which functions call this one?
3. Which structs embed this type, and which methods do they gain from it?
4. Which interface members does each implementer actually have?

What the analyzer sees in code like this

package cart

type Reader interface {              // bb records: interface Reader
	Read(p []byte) (int, error)      // bb records: method Read
}

type Cart struct {                  // bb records: struct Cart · field items
	items []Item
}

func (c *Cart) Read(p []byte) (int, error) { return 0, nil }

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Application & systems — the count beside each name is how many relationship types that family’s analyzer constructs.

• TypeScript14 types
• JavaScript12 types
• Python11 types
• Rust14 types
• Java10 types
• C++11 types
• C9 types
• C#11 types
• Swift11 types
• Kotlin11 types
• Dart13 types
• Zig8 types
• Objective-C11 types
• Visual Basic11 types
• VBA9 types