Addressing reviewer comments

Author: wrwg

apps/nextra/pages/en/build/smart-contracts/book/abort-and-assert.mdx

@@ -76,7 +76,8 @@ if (condition) () else abort code
 ```
 
 Since Move 2.0, `assert` without an error code is supported. If this assert is used, the
-abort code `0xD8CA26CBD9BE00000000` is generated. 
+abort code `0xCA26CBD9BE0B0000` is generated.  In terms of the `std::error` convention, this code has
+category `std::error::INTERNAL` and reason `0`.
 
 `assert` is more commonly used than just `abort` by itself. The `abort` examples above can be
 rewritten using `assert`

apps/nextra/pages/en/build/smart-contracts/book/enums.mdx

@@ -95,8 +95,8 @@ Notice above that the value matched is an immutable reference to an enum value.
 ```move
 fun scale_radius(self: &mut Rectangle, factor:  u64) {
     match (self) {
-        Circle{radius} => *radius = *radius * factor,
-        _              => {} // do nothing if not a Circle
+        Circle{radius: r} => *r = *r * factor,
+        _                 => {} // do nothing if not a Circle
   }
 }
 ```
@@ -106,19 +106,17 @@ The patterns provided in the match expression are evaluated sequentially, in ord
 Patterns can be nested and contain conditions, as in the following example:
 
 ```move
-use Result::*;
 let r : Result<Result<u64>> = Ok(Err(42));
 let v = match (r)) {
   Ok(Err(c)) if c < 42  => 0,
   Ok(Err(c)) if c >= 42 => 1,
   Ok(_)                 => 2,
-  _                     => 3 
+  _                     => 3
+};
 assert!(v == 1);
 ```
 
-Notice that in the above example, the last match clause (`_`) covers both patterns `Ok(Err(_))` and `Err(_)`.  Although at execution time, the earlier clauses may match `Ok(Err(c))` for all values of `c`, the compiler cannot be sure all cases are covered due to the conditionals: conditions in match expressions are not considered when tracking coverage.  Thus the first two clauses in the match expression above are not sufficient for match completeness, and an additional clause is required to avoid a compiler error.
-
-Notice that while match completeness is enforced by the compiler, at  runtime it may not be guaranteed if code is upgraded. See the discussion of upgrade compatibility of enums here.
+Notice that in the above example, the last match clause (`_`) covers both patterns `Ok(Err(_))` and `Err(_)`.  Although at execution time, the earlier clauses match `Ok(Err(c))` for all values of `c`, the compiler cannot be sure all cases are covered due to the conditionals: conditions in match expressions are not considered when tracking coverage.  Thus the first two clauses in the match expression above are not sufficient for match completeness, and an additional clause is required to avoid a compiler error.
 
 ## Testing Enum Variants
 
@@ -135,7 +133,6 @@ The operator allows specifying a list of variants, separated by "`|`" characters
 assert!(data is V1|V2);
 ```
 
-
 ## Selecting From Enum Values
 
 It is possible to directly select a field from an enum value. Recall the definition of versioned data:
@@ -153,19 +150,20 @@ One can write code as below to directly select the fields of variants:
 let s: String;
 let data1 = VersionedData::V1{name: s};
 let data2 = VersionedData::V2{name: s, age: 20};
-assert!(data1 is VersionData::V2);
 assert!(data1.name == data2.name)
-assert!(data2.age == 20); // Note that `data1.age` will abort!
+assert!(data2.age == 20); 
 ```
 
 Notice that field selection aborts if the enum value has no variant with the given field. This is the case for  `data1.age`. 
+The abort code used for this case is `0xCA26CBD9BE0B0001`. In terms of the `std::error` convention, this code has
+category `std::error::INTERNAL` and reason `1`.
 
 Field selection is only possible if the field is uniquely named and typed throughout all variants. Thus, the following yields a compile time error:
 
 ```move
 enum VersionedData has key {
   V1{name: String}
-  V3{name: u64}
+  V2{name: u64}
 }
 
 data.name

apps/nextra/pages/en/build/smart-contracts/book/functions.mdx

@@ -88,7 +88,7 @@ A `package` function can be only called within the same package. The notion of a
 defined by the hosting environment of Move, and not explicit in the language. Typically, the package
 is defined by a manifest file `Move.toml` which is processed by the build environment. 
 
-The following works, provided the two modules belong to the same package:
+The following works, provided the two modules belong to the same package and are at the same address:
 
 ```move
 module 0x42::m {
@@ -104,7 +104,10 @@ module 0x42::other {
 
 An attempt to access `0x42::m::foo` from another package will fail at compile time.
 
-Notice that package visibility is a compile time concept which is reduced by the compiler to friend visibility (described [below](#friend-visibility)), which can be verified by the Move VM.
+In addition to the notation `package fun`, also the longer notation `public(package) fun` is supported.
+
+Notice that package visibility is a compile time concept which is reduced by the compiler to friend visibility (described [below](#friend-visibility)), which can be verified by the Move VM. The Move VM guarantees that friend functions
+cannot be called across address boundaries, independent of what package system a compilation environment supports.
 
 
 #### `public(friend)` visibility
@@ -114,9 +117,9 @@ _Since Language Version 2.0_, `friend fun` replaces `public(friend) fun`. The ol
 The `public(friend)` visibility modifier is a more restricted form of the `public` modifier to give more control about where a function can be used. A `public(friend)` function can be called by:
 
 - other functions defined in the same module, or
-- functions defined in modules which are explicitly specified in the **friend list** (see [Friends](friends.mdx) on how to specify the friend list).
+- functions defined in modules which are explicitly specified in the **friend list** (see [Friends](friends.mdx) on how to specify the friend list), and which reside at the same address.
 
-Note that since we cannot declare a script to be a friend of a module, the functions defined in scripts can never call a `public(friend)` function.
+Note that since we cannot declare a script to be a friend of a module, the functions defined in scripts can never call a `public(friend)` function. 
 
 ```move
 address 0x42 {

apps/nextra/pages/en/build/smart-contracts/book/global-storage-operators.mdx

@@ -267,7 +267,7 @@ The table below gives an overview of index notations for storage:
 | `&T[address].field`     | `&borrow_global<T>(address).field`         |
 | `&mut T[address].field` | `&mut borrow_global_mut<T>(address).field` |
 | `T[address].field`      | `borrow_global<T>(address).field`          |
-| `T[address].field = x`  | `*borrow_global_mut<T>(address).field = x`  |
+| `T[address].field = x`  | `borrow_global_mut<T>(address).field = x`  |
 
 Here `T` represents a generic resource type that can take type parameters.
 

apps/nextra/pages/en/build/smart-contracts/book/structs-and-resources.mdx

@@ -487,8 +487,8 @@ module 0x2::m {
   struct Foo{ x: u8, y: u16, z: u32 }
   struct Bar(u8, u16, u32);
   
-  fun foo_get_x(self: &Foo): u8 { 
-    let Foo{x, ..} = self;
+  fun foo_get_x(self: &Foo): u16 { 
+    let Foo{y, ..} = self;
     x
   }
   

apps/nextra/pages/en/build/smart-contracts/book/vector.mdx

@@ -157,11 +157,11 @@ The table below gives an overview of index notations for vectors:
 | `&v[i]`           | `vector::borrow(&v, i)`                    |
 | `&mut v[i]`       | `vector::borrow_mut(&mut v, i)`            |
 | `v[i]`            | `*vector::borrow(&v, i)`                   |
-| `v[i] = x`        | `*vector::borrow(&v, i) = x`               |
+| `v[i] = x`        | `*vector::borrow_mut(&mut v, i) = x`       |
 | `&v[i].field`     | `&vector::borrow(&v, i).field`             |
 | `&mut v[i].field` | `&mut vector::borrow_mut(&mut v, i).field` |
-| `v[i].field`      | `vector::borrow(&v, i).field`               |
-| `v[i].field = x`  | `vector::borrow_mut(&mut v, i).field = x`       |
+| `v[i].field`      | `vector::borrow(&v, i).field`              |
+| `v[i].field = x`  | `vector::borrow_mut(&mut v, i).field = x`  |
 
 As an example, here is a bubble sort algorithm for vectors using index notation: