What Are You

Every function has a signature: its name, then its parameter types, no spaces, no names. This one is `supportsInterface(bytes4)`. Hash that text, keep the first four bytes, and you have the function selector, which is how a call names the function it wants when it arrives.

An interface id is built out of those selectors by the rule line 19 points at. This interface has exactly one function, so its id is that one selector: 0x01ffc9a7. Four bytes, derived from a name, and nothing else.

The rest of line 24 is vocabulary you already carry. `external`, so callers outside may ask. `view`, so anything implementing it promises to write nothing while answering. `returns (bool)`, so what comes back is one of exactly two values.

Line 22 adds something the compiler will never enforce, and the folder name on line 2 quietly names the whole subject. Tap the three lit lines and read what each one is doing.

The same twenty five lines, the same licence, the same release stamp. One line differs in a way worth noticing: this pragma is `^0.8.20` where the interface said `>=0.4.16`. A file with real code in it wants a ceiling, because a later language could change how that code behaves.

Line 6 names the file you have just finished reading and pulls it in. That import is the entire relationship between the two. The question lives in one file, and the answer is about to live in the other.

`abstract contract ERC165 is IERC165`. Two words you own already. Abstract, so this never deploys by itself and is meant to be built on. `is`, so it takes on everything the imported file declared, which in this case is a single line.

The compiler will now refuse to build any deployable contract in this family while that declaration has no body. Line 21 does not repeat the documentation, it points at the interface for it. There is exactly one thing left to supply, and it is the next line.

Line 22 is the declaration again with three changes: `public` where the interface said `external`, `virtual` added, and a brace where there was a semicolon. Virtual you know: it marks a function a later contract is allowed to replace.

Now read line 15, inside the comment. Same function, and it carries a word line 22 does not: `override`. Function first, it marks a function written to replace one the contract inherited. Decide why only one of these two lines needs it.

That is the famous part. One `==`, and the result goes straight back to the caller. There is no mapping, no registry, no list of supported interfaces, no loop over anything, and no storage touched. The four bytes handed in are compared against four bytes and that is the answer.

`type(IERC165).interfaceId` is not a lookup that happens when the call arrives. The compiler works it out while building and leaves a constant behind: 0x01ffc9a7, the selector you derived two steps ago. Everything around this line is naming.

The comment above the contract shows exactly what a later contract does. It writes its own `supportsInterface`, compares the four bytes against its own id on the left of the `||`, and on the right hands the same four bytes to `super.supportsInterface`.

`super` reaches the version this contract inherited, which is line 23. So the two comparisons run one after the other and either one of them saying yes is enough. Work out what a token built that way answers when the id it is handed is 0x01ffc9a7.

Read line 23 again for what it touches. One parameter that arrived with the call, and one constant the compiler already worked out. It does not read a single thing from storage. Solidity has a word for a function that reads nothing at all: `pure`, one notch stricter than `view`.

Line 22 says `view` anyway, and the reason is line 15. A contract replacing this may tighten the promise but never loosen it, so a `view` here still allows a child whose own answer reads storage. Writing `pure` would have shut that door for everyone downstream.

Twenty five lines, and the code is a pragma, an import, a contract line, a declaration, one return and the braces that close them. Everything else is a licence, a release stamp and a worked example written in prose above the thing it explains.

You can name the type, say where the four bytes come from, and follow the single comparison that settles the answer. One question left, and it is about what a yes is actually worth.

Two files behind you. One declares a question that costs four bytes to ask, the other answers it with the shortest body in the course. Between them they are the reason a contract can hold an address and find out something about what is there.

The name for all of this is introspection, and the machinery is a comparison. Everything else you read today was naming: the type, the selector, the id, the keywords. That is usually how it goes.