fix: several typos in the docs (#439)

* fix typo appendix-05-common-types-and-traits-and-cairo-prelude.md

* fix typo ch02-05-control-flow.md

* fix typo ch03-01-arrays.md

* fix typo ch03-03-custom-data-structures.md

* fix typo ch07-02-defining-modules-to-control-scope.md

* fix typo ch08-00-generic-types-and-traits.md

* fix typo ch08-01-generic-data-types.md

* fix typo ch08-02-traits-in-cairo.md

* fix typo ch10-01-unrecoverable-errors-with-panic.md

* fix typo ch11-02-macros.md

* Update ch07-02-defining-modules-to-control-scope.md

* Update ch07-02-defining-modules-to-control-scope.md

Author: tudorpintea999

src/appendix-05-common-types-and-traits-and-cairo-prelude.md

@@ -25,7 +25,7 @@ them explicitly into scope.
 ### List of common types and traits
 
 The following section provides a brief overview of commonly used types and
-traits when developping Cairo programs. Most of these are included in the
+traits when developing Cairo programs. Most of these are included in the
 prelude and not required to be imported explicitly - but not all of them.
 
 | Import                    | Path                                                  | Usage                                                                                                                                                                                  |

src/ch02-05-control-flow.md

@@ -117,7 +117,7 @@ Run panicked with err values: [375233589013918064796019]
 Remaining gas: 1050
 ```
 
-> Note: Cairo prevents us from running program with infinite loops by including a gas meter. The gas meter is a mechanism that limits the amount of computation that can be done in a program. By setting a value to the `--available-gas` flag, we can set the maximum amount of gas available to the program. Gas is a unit of measurements that expresses the computation cost of an instruction. When the gas meter runs out, the program will stop. In this case, the program panicked because it ran out of gas, as the stop condition was never reached.
+> Note: Cairo prevents us from running program with infinite loops by including a gas meter. The gas meter is a mechanism that limits the amount of computation that can be done in a program. By setting a value to the `--available-gas` flag, we can set the maximum amount of gas available to the program. Gas is a unit of measurement that expresses the computation cost of an instruction. When the gas meter runs out, the program will stop. In this case, the program panicked because it ran out of gas, as the stop condition was never reached.
 > It is particularly important in the context of smart contracts deployed on Starknet, as it prevents from running infinite loops on the network.
 > If you're writing a program that needs to run a loop, you will need to execute it with the `--available-gas` flag set to a value that is large enough to run the program.
 

src/ch03-01-arrays.md

@@ -2,7 +2,7 @@
 
 An array is a collection of elements of the same type. You can create and use array methods by importing the `array::ArrayTrait` trait.
 
-An important thing to note is that arrays have limited modifications options. Arrays are, in fact, queues whose values can't be modified.
+An important thing to note is that arrays have limited modification options. Arrays are, in fact, queues whose values can't be modified.
 This has to do with the fact that once a memory slot is written to, it cannot be overwritten, but only read from it. You can only append items to the end of an array and remove items from the front using `pop_front`.
 
 ### Creating an Array
@@ -13,7 +13,7 @@ Creating an Array is done with the `ArrayTrait::new()` call. Here is an example
 {{#include ../listings/ch03-common-collections/no_listing_00_array_new_append/src/lib.cairo}}
 ```
 
-When required, you can pass the expected type of items inside the array when instantiating the array like this, or explicitly define the type the variable.
+When required, you can pass the expected type of items inside the array when instantiating the array like this, or explicitly define the type of the variable.
 
 ```rust, noplayground
 let mut arr = ArrayTrait::<u128>::new();

src/ch03-03-custom-data-structures.md

@@ -18,7 +18,7 @@ level_players.append(10);
 
 But then you realize you can't increase the level at a specific index once it's
 set. If a player dies, you cannot remove it from the array unless he happens to
-be the in the first position.
+be in the first position.
 
 Fortunately, Cairo provides a handy built-in [dictionary
 type](./ch03-02-dictionaries.md) called `Felt252Dict<T>` that allows us to

src/ch08-00-generic-types-and-traits.md

@@ -1,11 +1,11 @@
 # Generic Types and Traits
 
-Every programming language has tools for effectively handling the duplication of concepts. In Cairo, one such tool is generics: abstract stand-ins for concrete types or other properties. We can express the behaviour of generics or how they relate to other generics without knowing what will be in their place when compiling and running the code.
+Every programming language has tools for effectively handling the duplication of concepts. In Cairo, one such tool is generics: abstract stand-ins for concrete types or other properties. We can express the behavior of generics or how they relate to other generics without knowing what will be in their place when compiling and running the code.
 
-Functions, structs, enums and traits can incorporate generic types as part of their definition instead of a concrete types like `u32` or `ContractAddress`.
+Functions, structs, enums and traits can incorporate generic types as part of their definition instead of a concrete type like `u32` or `ContractAddress`.
 
 Generics allow us to replace specific types with a placeholder that represents multiple types to remove code duplication.
 
 For each concrete type that replaces a generic type the compiler creates a new definition, reducing development time for the programmer, but code duplication at compile level still exists. This may be of importance if you are writing Starknet contracts and using a generic for multiple types which will cause contract size to increment.
 
-Then you’ll learn how to use traits to define behavior in a generic way. You can combine traits with generic types to constrain a generic type to accept only those types that have a particular behavior, as opposed to just any type.
+Then you’ll learn how to use traits to define behavior in a generic way. You can combine traits with generic types to constrain a generic type to accept only those types that have a particular behavior, as opposed to just any type.

src/ch08-01-generic-data-types.md

@@ -20,9 +20,9 @@ The new `largest_list` function includes in its definition the requirement that
 
 ### Constraints for Generic Types
 
-When defining generic types, it is useful to have information about them. Knowing which traits a generic type implements allow us to use them more effectively in a functions logic at the cost of constraining the generic types that can be used with the function. We saw an example of this previously by adding the `TDrop` implementation as part of the generic arguments of `largest_list`. While `TDrop` was added to satisfy the compilers requirements, we can also add constraints to benefit our function logic.
+When defining generic types, it is useful to have information about them. Knowing which traits a generic type implements allow us to use them more effectively in a functions logic at the cost of constraining the generic types that can be used with the function. We saw an example of this previously by adding the `TDrop` implementation as part of the generic arguments of `largest_list`. While `TDrop` was added to satisfy the compiler's requirements, we can also add constraints to benefit our function logic.
 
-Imagine that we want, given a list of elements of some generic type `T`, find the smallest element among them. Initially, we know that for an element of type `T` to be comparable, it must implement the `PartialOrd` trait. The resulting function would be:
+Imagine that we want, given a list of elements of some generic type `T`, to find the smallest element among them. Initially, we know that for an element of type `T` to be comparable, it must implement the `PartialOrd` trait. The resulting function would be:
 
 ```rust
 {{#include ../listings/ch08-generic-types-and-traits/no_listing_03_missing_tcopy/src/lib.cairo}}

src/ch08-02-traits-in-cairo.md

@@ -26,7 +26,7 @@ In the code above, `RectangleGeometry` implements the trait `ShapeGeometry` defi
 
 ## Implementing a trait, without writing its declaration.
 
-You can write implementations directly without definining the corresponding trait. This is made possible by using the `#[generate_trait]` attribute with on the implementation, which will make the compiler generate the trait corresponding to the implementation automatically. Remember to add `Trait` as a suffix to your trait name, as the compiler will create the trait by adding a `Trait` suffix to the implementation name.
+You can write implementations directly without defining the corresponding trait. This is made possible by using the `#[generate_trait]` attribute within the implementation, which will make the compiler generate the trait corresponding to the implementation automatically. Remember to add `Trait` as a suffix to your trait name, as the compiler will create the trait by adding a `Trait` suffix to the implementation name.
 
 ```rust,noplayground
 {{#include ../listings/ch08-generic-types-and-traits/no_listing_15_generate_trait/src/lib.cairo}}
@@ -63,7 +63,7 @@ To use traits methods, you need to make sure the correct traits/implementation(s
 In some cases you might need to import not only the trait but also the implementation if they are declared in separate modules.
 If `CircleGeometry` was in a separate module/file `circle` then to use `boundary` on `circ: Circle`, we'd need to import `CircleGeometry` in addition to `ShapeGeometry`.
 
-If the code was organised into modules like this, where the implementation of a trait was defined in a different module than the trait itself, explicitly importing the relevant implementation is required.
+If the code was organized into modules like this, where the implementation of a trait was defined in a different module than the trait itself, explicitly importing the relevant implementation is required.
 
 ```rust,noplayground
 use debug::PrintTrait;

src/ch10-01-unrecoverable-errors-with-panic.md

@@ -2,7 +2,7 @@
 
 In Cairo, unexpected issues may arise during program execution, resulting in runtime errors. While the panic function from the core library doesn't provide a resolution for these errors, it does acknowledge their occurrence and terminates the program. There are two primary ways that a panic can be triggered in Cairo: inadvertently, through actions causing the code to panic (e.g., accessing an array beyond its bounds), or deliberately, by invoking the panic function.
 
-When a panic occurs, it leads to an abrupt termination of the program. The `panic` function takes an array as argument, which can be used to provide an error message and performs an unwind process where all variables are dropped and dictionaries squashed to ensure the soundness of the program to safely terminate the execution.
+When a panic occurs, it leads to an abrupt termination of the program. The `panic` function takes an array as an argument, which can be used to provide an error message and performs an unwind process where all variables are dropped and dictionaries squashed to ensure the soundness of the program to safely terminate the execution.
 
 Here is how we can `panic` from inside a program and return the error code `2`:
 
@@ -21,7 +21,7 @@ Run panicked with [2 (''), ].
 
 As you can notice in the output, the print statement is never reached, as the program terminates after encountering the `panic` statement.
 
-An alternative and more idiomatic approach to panic in Cairo would be to use the `panic_with_felt252` function. This function serves as an abstraction of the array-defining process and is often preferred due to its clearer and more concise expression of intent. By using `panic_with_felt252`, developers can panic in a one-liner by providing a felt252 error message as argument, making the code more readable and maintainable.
+An alternative and more idiomatic approach to panic in Cairo would be to use the `panic_with_felt252` function. This function serves as an abstraction of the array-defining process and is often preferred due to its clearer and more concise expression of intent. By using `panic_with_felt252`, developers can panic in a one-liner by providing a felt252 error message as an argument, making the code more readable and maintainable.
 
 Let's consider an example:
 

src/ch11-02-macros.md

@@ -21,12 +21,12 @@ With `array!`:
 
 ### `consteval_int!`
 
-In some situtations, a developer might need to declare a constant that is the result of a computation of integers. To compute a constant expression and use its result at compile time, it is required to use the `consteval_int!` macro.
+In some situations, a developer might need to declare a constant that is the result of a computation of integers. To compute a constant expression and use its result at compile time, it is required to use the `consteval_int!` macro.
 
 Here is an example of `consteval_int!`:
 
 ```rust
 const a: felt252 = consteval_int!(2 * 2 * 2);
 ```
 
-This will be interprated as `const a: felt252 = 8;` by the compiler.
+This will be interpreted as `const a: felt252 = 8;` by the compiler.