Book Updates

-add chapter 4.2

Author: ktechhydle

book/chapter4.1.md

@@ -2,76 +2,6 @@
 title: "Chapter 4.1"
 ---
 
-# Functions
-
-If you want your program to have some sort of organization, it is best to put sections of code into functions.
-
-Functions are essentially re-usable blocks of code that can be executed any moment in a program. You can give them objects to use (often called arguments) and they can give a result after execution (returned value).
-
-```
-func my_function(argument) {
-    bark(argument);
-}
-
-my_function("Hello, world!");
-```
-
-## Function Definitions
-
-As complex as it may seem, creating your own functions is relatively simple. To start, you give it a name, similar to variables, followed by arguments and the code to execute.
-
-```
-func the_name_of_a_function(argument1, argument2) {
-    # ...
-}
-```
-
-Arguments are objects you can give the function when calling it (executing it). The arguments can be used inside the function's code, where the code will be ran when calling the function.
-
-```
-func define_x(value) {
-    obj x = value;
-}
-```
-
-Inside the function's code, you have the option to return a value from the function when it is called with the `give` keyword.
-
-```
-func return_value(value) {
-    give value;
-}
-
-bark(return_value("Hello, world!")); # outputs 'Hello, world!'
-```
-
-## Function Calls
-
-After a function is defined, you may need to use it. The function's code is **never** ran until you call it.
-
-To call your function, use it's name followed by parenthesis with the arguments you gave your function (if none, don't provide any arguments.)
-
-```
-func my_function(x) {
-    give(x + 1);
-}
-
-obj ten_plus_one = my_function(10);
-```
-
-During calls, arguments are positional. This means we can't give a function with 2 arguments 10 arguments. If function takes _x_ arguments, give it _x_ arguments.
-
-```
-func no_args() {
-    give;
-}
-
-no_args("Secret argument"); # this line will cause an error
-```
-
----
-title: "Chapter 4.1"
----
-
 # Chapter 4.1: Functions
 
 If you want your program to stay organized and readable, it’s best to group related code into **functions**.

book/chapter4.2.md

@@ -0,0 +1,106 @@
+---
+title: "Chapter 4.2"
+---
+
+# Chapter 4.2: Scope
+
+When you create variables or functions, they don’t always live *everywhere* in your program. Where something “lives” and can be accessed from is called its **scope**.
+
+You can think of scope like a neighborhood:
+
+If a variable is defined inside one neighborhood (a function), it can’t just walk into another one unless it’s allowed.
+
+```
+func say_hi() {
+    obj message = "Hello!";
+    bark(message);
+}
+
+say_hi();
+bark(message);  # message doesn’t exist here
+```
+
+Here, the variable `message` was created inside the function `say_hi`. That means it only exists within that function and nowhere else.
+
+## Local Scope
+
+Variables declared **inside** a function are called **local variables**.
+
+They live only as long as the function is running.
+
+```
+func make_cookie() {
+    obj dough = "Sweet dough";
+    bark(dough);
+}
+
+make_cookie();
+bark(dough);  # dough is gone, only existed inside make_cookie
+```
+
+Local scope keeps your code safe from accidental variable name collisions. Two different functions can both have a variable named `x`, and they won’t mess each other up.
+
+```
+func one() {
+    obj x = 1;
+    bark(x);
+}
+
+func two() {
+    obj x = 2;
+    bark(x);
+}
+
+one();  # outputs 1
+two();  # outputs 2
+```
+
+## Global Scope
+
+If you create a variable outside of any function, it’s considered **global**. That means every function can access it (unless it gets shadowed).
+
+```
+obj mood = "Happy";
+
+func show_mood() {
+    bark(mood);
+}
+
+show_mood();  # outputs "Happy"
+```
+
+If you redefine a variable with the same name **inside** a function,
+the inner one hides (or **shadows**) the global one, modifying it:
+
+```
+obj mood = "Happy";
+
+func show_mood() {
+    mood = "Angry";
+    bark(mood);
+}
+
+show_mood();  # prints "Angry"
+bark(mood);   # prints "Angry"
+```
+
+## Nested Scope
+
+Functions can live inside other functions, inner functions can see variables from their outer ones, but not the other way around.
+
+```
+func outer() {
+    obj outer_value = "Outside";
+
+    func inner() {
+        bark(outer_value);  # ✅ can see outer_value
+    }
+
+    inner();
+}
+
+outer();
+bark(outer_value);  # not visible here
+```
+
+This is called **lexical scope**, meaning a function’s visibility is determined by where it was written, not where it’s called.