chore(docs): show self or the extended type for referencing internal and extension functions, respectively (#3207)

Author: novusnota

docs/src/content/docs/book/cells.mdx

@@ -433,7 +433,7 @@ let areSlicesNotEqual = aSlice != bSlice; // false
 
 Note that direct comparison via the `=={:tact}` or `!={:tact}` operators implicitly uses [SHA-256](https://en.wikipedia.org/wiki/SHA-2#Hash_standard) hashes of the [standard `Cell{:tact}` representation](#cells-representation) under the hood.
 
-Explicit comparisons using `.hash(){:tact}` are also available:
+Explicit comparisons using the `hash(){:tact}` extension function that works on cells and slices are also available:
 
 ```tact
 let a = beginCell().storeUint(123, 8).endCell();

docs/src/content/docs/book/debug.mdx

@@ -716,7 +716,7 @@ it('emits', async () => {
 });
 ```
 
-To parse the second emitted message, we could manually use several `.loadSomething(){:typescript}` functions, but that's overly brittle — if the fields of the `Ballroom{:tact}` [struct][struct] ever change, you'd need to start all over. That could significantly backfire when you have numerous tests written in that manner.
+To parse the second emitted message, we could manually use various [`Slice{:tact}`][slice] extension functions, but that's overly brittle — if the fields of the `Ballroom{:tact}` [struct][struct] ever change, you'd need to start all over. That could significantly backfire when you have numerous tests written in that manner.
 
 Fortunately, the Tact compiler auto-generates [TypeScript bindings (or wrappers)](/book/compile#wrap-ts) for contracts, making it easy to reuse them in your test suite. Not only do they provide wrappers for the contract you're testing, but they also export helper functions to store or load structs and [Messages][message] defined in the contract. These helper functions have names similar to their corresponding structures, prefixed with `load`.
 

docs/src/content/docs/book/exit-codes.mdx

@@ -288,7 +288,7 @@ From the [Cells, Builders and Slices page](/book/cells#cells) of the Book:
 
 To construct a [`Cell{:tact}`][cell], a [`Builder{:tact}`][builder] is used. If you try to store more than 1023 bits of data or more than 4 references to other cells, an error with exit code $8$ is thrown: `Cell overflow`.
 
-This error can be triggered by [manual construction](/book/cells#cnp-manually) of the cells via [relevant `.storeSomething()` methods](/ref/core-cells#builder) or when [using structs and Messages and their convenience methods](/book/cells#cnp-structs).
+This error can be triggered by [manual construction](/book/cells#cnp-manually) of the cells via [relevant `Builder{:tact}` methods](/ref/core-cells#builder) or when [using structs and Messages and their convenience methods](/book/cells#cnp-structs).
 
 ```tact
 // Too many bits
@@ -326,7 +326,7 @@ From the [Cells, Builders and Slices page](/book/cells#cells) of the Book:
 
 To parse a [`Cell{:tact}`][cell], a [`Slice{:tact}`][slice] is used. If you try to load more data or references than a `Slice{:tact}` contains, an error with exit code 9 is thrown: `Cell underflow`.
 
-The most common cause of this error is a mismatch between the expected and actual memory layouts of the cells, so it's recommended to [use structs and Messages for parsing](/book/cells#cnp-structs) the cells instead of [manual parsing](/book/cells#cnp-manually) via [relevant `.loadSomething()` methods](/ref/core-cells#slice).
+The most common cause of this error is a mismatch between the expected and actual memory layouts of the cells, so it's recommended to [use structs and Messages for parsing](/book/cells#cnp-structs) the cells instead of [manual parsing](/book/cells#cnp-manually) via [relevant `Slice{:tact}` methods](/ref/core-cells#slice).
 
 ```tact
 // Too few bits

docs/src/content/docs/book/operators.mdx

@@ -427,8 +427,8 @@ Both operators can be applied to the following list of types and values:
 * [`Int{:tact}`][int]
 * [`Bool{:tact}`][bool]
 * [`Address{:tact}`][p]
-* [`Cell{:tact}`][cell], implicitly compared via [`.hash(){:tact}`](/ref/core-cells#cellhash)
-* [`Slice{:tact}`][slice], implicitly compared via [`.hash(){:tact}`](/ref/core-cells#slicehash)
+* [`Cell{:tact}`][cell], implicitly compared via [`Cell.hash(){:tact}`](/ref/core-cells#cellhash)
+* [`Slice{:tact}`][slice], implicitly compared via [`Slice.hash(){:tact}`](/ref/core-cells#slicehash)
 * [`String{:tact}`][p]
 * [`map<K, V>{:tact}`](/book/maps), but only if their key and value types are identical
 * [Optionals and `null{:tact}` value](/book/optionals)
@@ -478,7 +478,7 @@ nullable != anotherNullable; // true
 
 :::note
 
-  The binary equality `=={:tact}` and inequality `!={:tact}` operators implicitly compare [maps](/book/maps) by the hashes of their respective [cells][cell] via the [`.hash(){:tact}`](/ref/core-cells#cellhash) function. While this is acceptable in the majority of cases—since most map serializers behave identically to the serializer from TON Blockchain sources—it is still possible to obtain false-negative results if a map is serialized manually or if the serialization logic is modified in certain libraries.
+  The binary equality `=={:tact}` and inequality `!={:tact}` operators implicitly compare [maps](/book/maps) by the hashes of their respective [cells][cell] via the [`hash(){:tact}`](/ref/core-cells#cellhash) extension function. While this is acceptable in the majority of cases—since most map serializers behave identically to the serializer from TON Blockchain sources—it is still possible to obtain false-negative results if a map is serialized manually or if the serialization logic is modified in certain libraries.
 
   If you need to guarantee that compared maps are equal and are willing to pay significantly more gas, use the [`map.deepEquals(){:tact}`](/book/maps#deepequals) function.
 

docs/src/content/docs/book/send.mdx

@@ -33,7 +33,7 @@ self.reply("Hello, World!".asComment()); // asComment converts a String to a Cel
 
 If you need more advanced logic, you can use the `send(){:tact}` function and the `SendParameters{:tact}` [struct][struct] directly.
 
-In fact, the previous example with [`.reply(){:tact}`](#send-simple-reply) can be made using the following call to the `send(){:tact}` function:
+In fact, the previous example with [`self.reply(){:tact}`](#send-simple-reply) can be made using the following call to the `send(){:tact}` function:
 
 ```tact
 send(SendParameters {

docs/src/content/docs/book/statements.mdx

@@ -500,7 +500,7 @@ do {
 
 The `foreach{:tact}` loop operates on key-value pairs (entries) of the [`map<K, V>{:tact}`](/book/maps) type in sequential order: from the smallest keys of the map to the biggest ones.
 
-This loop executes a block of code for each entry in the given map, capturing the key and value on each iteration. This is handy when you don't know in advance how many items there are in the map or don't want to explicitly look for each of the entries using the [`.get(){:tact}`](/book/maps#get) [method](/book/functions#extensions) of maps.
+This loop executes a block of code for each entry in the given map, capturing the key and value on each iteration. This is handy when you don't know in advance how many items there are in the map or don't want to explicitly look for each of the entries using the [`get(){:tact}`](/book/maps#get) [method](/book/functions#extensions) of maps.
 
 Note that the names of captured keys and values in each iteration are arbitrary and can be any valid Tact identifier, provided they are new to the current scope. The most common options are: `k` and `v`, or `key` and `value`.
 

docs/src/content/docs/book/structs-and-messages.mdx

@@ -276,7 +276,7 @@ fun conversionFun() {
 
 ### Obtain from a `Cell` or `Slice`, `.fromCell()` and `.fromSlice()` {#fromcellslice}
 
-Instead of manually parsing a [`Cell{:tact}`][cell] or [`Slice{:tact}`][slice] via a series of relevant `.loadSomething(){:tact}` function calls, one can use `.fromCell(){:tact}` and `.fromSlice(){:tact}` [extension functions](/book/functions#extensions) to convert the provided [`Cell{:tact}`][cell] or [`Slice{:tact}`][slice] into the needed [struct](#structs) or [Message](#messages).
+Instead of manually parsing a [`Cell{:tact}`][cell] or [`Slice{:tact}`][slice] via a series of relevant `Slice{:tact}` extension function calls, one can use `.fromCell(){:tact}` and `.fromSlice(){:tact}` [extension functions](/book/functions#extensions) to convert the provided `Cell{:tact}` or `Slice{:tact}` into the needed [struct](#structs) or [Message](#messages).
 
 These extension functions only attempt to parse a [`Cell{:tact}`][cell] or [`Slice{:tact}`][slice] according to the structure of your struct or Message. In case the layouts don't match, various exceptions may be thrown — make sure to wrap your code in [`try...catch{:tact}`](/book/statements#try-catch) blocks to prevent unexpected results.
 

docs/src/content/docs/cookbook/single-communication.mdx

@@ -87,7 +87,7 @@ contract Example {
 }
 ```
 
-The latter example is identical to using the [`.reply(){:tact}` function](#how-to-make-a-basic-reply).
+The latter example is identical to using the [`self.reply(){:tact}` function](#how-to-make-a-basic-reply).
 
 ## How to send a message with a long text comment
 

docs/src/content/docs/zh-cn/book/cells.mdx

@@ -408,7 +408,7 @@ let areSlicesNotEqual = aSlice != bSlice; // false
 
 请注意，通过 `=={:tact}` 或 `!={:tact}` 操作符进行的直接比较隐含地使用了[标准 `Cell{:tact}` 表示法](#cells-representation)的 [SHA-256](https://en.wikipedia.org/wiki/SHA-2#Hash_standard) 哈希值。
 
-还可使用 `.hash(){:tact}` 进行显式比较：
+还可使用 `Cell.hash(){:tact}` 或 `Slice.hash(){:tact}` 进行显式比较：
 
 ```tact
 let a = beginCell().storeUint(123, 8).endCell();

docs/src/content/docs/zh-cn/book/exit-codes.mdx

@@ -285,7 +285,7 @@ contract VibeCheck {
 
 要构建一个 [`cellent{:tact}`][cell], 使用 [`Builder{:tact}`][builder] 如果尝试存储的数据超过 $1023$ 位，或对其他cell的引用超过 $4$ ，则会出现退出码为 $8$ 的错误："`Cell overflow`。
 
-这个错误可以由[手动construction](/zh-cn/book/cells#cnp-manual y) 通过[relevant `.loadSomething()`方法](/zh-cn/ref/core-cells) 或[使用结构和消息及其方便方法](/zh-cn/book/cells#cnp-structs) 触发。
+这个错误可以由[手动construction](/zh-cn/book/cells#cnp-manual y) 通过[relevant `Builder.storeSomething(){:tact}`方法](/zh-cn/ref/core-cells) 或[使用结构和消息及其方便方法](/zh-cn/book/cells#cnp-structs) 触发。
 
 ```tact
 // Too much bits
@@ -323,7 +323,7 @@ try {
 
 若要解析[`cell{:tact}`][cell]，请使用 [`slice{:tact}`][slice] 如果你试图加载比`slice{:tact}`更多的数据或引用，则退出码 $9$ 的错误就会抛出：“cell下溢”。
 
-此错误的最常见原因是cell的预期内存布局和实际内存布局不匹配， 因此建议[使用结构和消息进行解析](/zh-cn/book/cells#cnp-structs) ，而不是[手动解析](/zh-cn/book/cells#cnp-manually) 通过 [relevant `. oadSomething()` 方法](/zh-cn/ref/core-cells)。
+此错误的最常见原因是cell的预期内存布局和实际内存布局不匹配， 因此建议[使用结构和消息进行解析](/zh-cn/book/cells#cnp-structs) ，而不是[手动解析](/zh-cn/book/cells#cnp-manually) 通过 [relevant `Slice.loadSomething(){:tact}`方法](/zh-cn/ref/core-cells)。
 
 ```tact
 // Too few bits