Update documentations

Author: leeyi45

docs/src/modules/1-getting-started/3-git.md

@@ -38,7 +38,7 @@ Make sure that the branch is named appropriately. For example, if you were creat
 
 ## Procedure for Pull Requests
 
-When you're ready for your work to be incorporated into the `master` branch, open a pull request with the modules repository to merge your
+When you're ready for your work to be incorporated into the `master` branch, [open](https://github.com/source-academy/modules/compare) a pull request with the modules repository to merge your
 changes into `master` branch. Make sure that your branch is up-to-date with the `master` branch (by performing a `git merge` from the `master` branch to your own branch).
 
 This will automatically trigger the repository's workflows, which will verify that your changes don't break any of the existing code. If the
@@ -57,4 +57,5 @@ the `dist` folders are ignored for all bundles and tabs, but if you need to add
 directory.
 
 > [!TIP]
-> If you want to remove a file that been committed in the past you can use `git rm`
+> If you want to remove a file that been committed in the past you can use `git rm` or\
+> `git rm --cached`.

docs/src/modules/2-bundle/4-conventions/1-basic.md

@@ -27,7 +27,7 @@ export function exposed_function() {
 Neither default nor rest parameters are currently supported due to an [issue](https://github.com/source-academy/js-slang/issues/1238) on the `js-slang` side.
 :::
 
-## 2. Cadet facing functions should not use array destructuring for parameters
+## 2. Cadet facing functions should not use destructuring for parameters
 
 Javascript allows us to destruct iterables directly within a function's parameters:
 
@@ -48,36 +48,72 @@ function foo([x, y]) {
 TypeError: number 0 is not iterable (cannot read property Symbol(Symbol.iterator))
 ```
 
-If instead the parameter isn't destructured, it gives you the chance to perform type checking:
-
+Javascript also supports object destructuring in parameters:
 ```ts
-export function foo(arr: [string, string]) {
-  if (!Array.isArray(arr)) throw new Error();
-  return arr[0];
+interface BarParams {
+  x: string;
+  y: string;
 }
-```
 
-More information about throwing errors and why this kind of type checking is important can be found [here](./3-errors#source-type-checking).
-
-::: details What about Object Destructuring?
-Javascript also supports object destructuring in parameters:
-```js
-function foo({ x, y }) {
+function bar({ x, y }: BarParams) {
   return x;
 }
 ```
 
-However, Javascript doesn't actually throw an error if you pass an invalid object into this function:
-```js
-function foo({ x, y }) {
+However, Javascript doesn't actually throw an error if you pass an invalid object into the function:
+```ts
+function bar({ x, y }: BarParams) {
   return x;
 }
 
-console.log(foo(0)); // prints undefined
+console.log(bar(0)); // prints undefined
 ```
 
 If an invalid argument gets passed, no error is thrown and the destructured values just take on the value of `undefined` (which you might want to check for).
-:::
+
+However, if you use nested destructuring, Javascript _will_ throw an error:
+```ts
+interface Bar2Params {
+  x: {
+    a: string;
+    b: string;
+  };
+}
+
+function bar2({ x: { a, b } }: Bar2Params) {
+  return a;
+}
+
+console.log(bar2(0));
+```
+
+The call to `bar2` causes an error like the one below:
+```sh
+Uncaught TypeError: Cannot read properties of undefined (reading 'a')
+  at bar2 (<anonymous>:1:21)
+  at <anonymous>:1:1
+```
+because of course, when `bar2` is called with `0`, `x` becomes `undefined` and trying to destructure `undefined` causes the `TypeError`.
+
+If instead the parameter isn't destructured, it gives you the chance to perform type checking:
+
+```ts
+export function foo(arr: [string, string]) {
+  if (!Array.isArray(arr)) throw new Error();
+  return arr[0];
+}
+
+export function bar2(obj: Bar2Params) {
+  if (typeof obj !== 'object' || !('x' in obj)) {
+    // throw an error....
+  }
+
+  return obj.x;
+}
+```
+
+> [!IMPORTANT]
+> More information about throwing errors and why this kind of type checking is important can be found [here](./3-errors#source-type-checking).
 
 ## 3. If your bundle requires specific Source features, make sure to indicate it in the manifest
 

docs/src/modules/2-bundle/4-conventions/2-abstractions.md

@@ -95,6 +95,12 @@ but if your circumstances can't support it you can refer to the second method wh
 > This means that is is unnecessary to implement `ReplResult` for any of your top-level functions. You can still override this automatic functionality by implementing
 > `ReplResult`.
 
+> [!INFO]
+> The `ReplResult` interface can be imported from `@sourceacademy/modules-lib/types`.  To use it, you will have to
+> add the `@sourceacademy/modules-lib` package to your dependencies.
+>
+> Using the interface as exported will be helpful for type checking, but it is not necessary.
+
 ### Implementing `ReplResult` directly
 
 The simplest way to implement the interface is to do it in Typescript. For example, the `curve` bundle has a `Point` class, which is an abstraction of a point in 3D space with a color value: