docs: Clean redundancy in docs and typos.

Author: dylan-sutton-chavez

docs/pages/reference/builtins.md

@@ -438,7 +438,7 @@ import prod_handler
 import dev_handler
 
 def handle(env, request):
-    return import_module(env + "_handler").handle(request)
+  return import_module(env + "_handler").handle(request)
 
 handle("prod", req)
 handle("dev",  req)
@@ -544,18 +544,18 @@ Functions, type objects, and user classes expose `__name__` (the bare declared n
 
 ```python
 def greet():
-    pass
+  pass
 
 class Box:
-    pass
+  pass
 
 print(greet.__name__)
 print(int.__name__)
 print(Box.__name__)
 try:
-    1 / 0
+  1 / 0
 except Exception as e:
-    print(type(e).__name__)
+  print(type(e).__name__)
 ```
 
 ```text Output
@@ -591,10 +591,10 @@ print(issubclass(bool, int))
 print(issubclass(KeyError, (ValueError, Exception)))
 
 class A:
-    pass
+  pass
 
 class B(A):
-    pass
+  pass
 
 print(issubclass(B, A))
 print(issubclass(A, B))
@@ -745,9 +745,9 @@ fn = globals()['add']
 print(fn(3, 4))
 
 def f():
-    a = 1
-    b = 2
-    return locals()
+  a = 1
+  b = 2
+  return locals()
 print(f())
 ```
 
@@ -765,8 +765,8 @@ Dicts are copies, mutation doesn't change VM bindings.
 
 ```python
 class Box:
-    def __init__(self):
-        pass
+  def __init__(self):
+    pass
 
 b = Box()
 setattr(b, "x", 42)
@@ -802,9 +802,9 @@ print(xs[slice(0, 5, 2)])
 
 ```python
 class P:
-    def __init__(self):
-        self.x = 1
-        self.y = 2
+  def __init__(self):
+    self.x = 1
+    self.y = 2
 
 p = P()
 print(vars(p))
@@ -822,12 +822,12 @@ print(vars(p))
 
 ```python
 class A:
-    def m(self):
-        return "a"
+  def m(self):
+    return "a"
 
 class B(A):
-    def m(self):
-        return super().m() + "b"
+  def m(self):
+    return super().m() + "b"
 
 print(B().m())
 ```
@@ -842,14 +842,14 @@ ab
 
 ```python
 class C:
-    def __init__(self, x):
-        self._x = x
-    @property
-    def x(self):
-        return self._x
-    @x.setter
-    def x(self, v):
-        self._x = v
+  def __init__(self, x):
+    self._x = x
+  @property
+  def x(self):
+    return self._x
+  @x.setter
+  def x(self, v):
+    self._x = v
 
 c = C(1)
 c.x = 9
@@ -878,9 +878,9 @@ Concurrency primitives; full model in [Async](/language/async).
 
 ```python
 async def animate(node):
-    for i in range(60):
-        set_attribute(node, "style", f"transform: translateX({i}px)")
-        frame()
+  for i in range(60):
+    set_attribute(node, "style", f"transform: translateX({i}px)")
+    frame()
 ```
 
 ### receive
@@ -893,7 +893,7 @@ async def animate(node):
 
 ```python
 async def task(n):
-    return n * 2
+  return n * 2
 
 print(gather(task(1), task(2), task(3)))
 ```
@@ -908,13 +908,13 @@ print(gather(task(1), task(2), task(3)))
 
 ```python
 async def slow():
-    sleep(10)
-    return "never"
+  sleep(10)
+  return "never"
 
 try:
-    with_timeout(0.1, slow())
+  with_timeout(0.1, slow())
 except TimeoutError:
-    print("timed out")
+  print("timed out")
 ```
 
 ```text Output

docs/pages/reference/imports.md

@@ -34,9 +34,9 @@ from utils import normalize as n
 
 # Parenthesized name lists, multi-line, optional trailing comma
 from utils import (
-    slugify,
-    normalize as n,
-    titlecase,
+  slugify,
+  normalize as n,
+  titlecase,
 )
 
 # Plain `import X`, binds the module under its name; access exports via `.`

docs/pages/reference/limits-and-errors.md

@@ -27,9 +27,9 @@ print(140737488355327) # inline, fast path
 print(2 ** 47) # 140737488355328: auto-promotes to LongInt
 print(2 ** 100) # 1267650600228229401496703205376
 try:
-    print(2 ** 127) # past the i128 cap
+  print(2 ** 127) # past the i128 cap
 except OverflowError:
-    print("overflow")
+  print("overflow")
 ```
 
 ```text Output
@@ -53,9 +53,9 @@ def loop(n):
     return loop(n + 1)
 
 try:
-    loop(0)
+  loop(0)
 except RecursionError:
-    print("hit max depth")
+  print("hit max depth")
 ```
 
 ```text Output
@@ -65,11 +65,11 @@ hit max depth
 ```python
 # Heap quota, a tight loop allocating new objects
 try:
-    xs = []
-    while True:
-        xs = xs + [0] * 1000
+  xs = []
+  while True:
+    xs = xs + [0] * 1000
 except MemoryError:
-    print("hit heap limit")
+  print("hit heap limit")
 ```
 
 ## Source size
@@ -142,14 +142,14 @@ Flat tree rooted at `BaseException -> Exception`. `except` walks parent links, `
 
 ```python
 try:
-    raise RuntimeError("oops")
+  raise RuntimeError("oops")
 except Exception as e:
-    print("caught via parent:", e)
+  print("caught via parent:", e)
 
 try:
-    [][0]
+  [][0]
 except Exception:
-    print("caught IndexError as Exception")
+  print("caught IndexError as Exception")
 ```
 
 ```text Output
@@ -165,19 +165,19 @@ Caught exceptions expose constructor args as `e.args` (tuple). `raise X("msg")`
 
 ```python
 try:
-    raise TypeError("bad input")
+  raise TypeError("bad input")
 except TypeError as e:
-    print(e.args)
+  print(e.args)
 
 try:
-    1 / 0
+  1 / 0
 except ZeroDivisionError as e:
-    print(e.args)
+  print(e.args)
 
 try:
-    raise ValueError
+  raise ValueError
 except ValueError as e:
-    print(e.args)
+  print(e.args)
 ```
 
 ```text Output
@@ -190,16 +190,16 @@ except ValueError as e:
 
 ```python
 def safe(f, x):
-    try:
-        return f(x)
-    except TypeError:
-        return "type"
-    except ValueError:
-        return "value"
-    except ZeroDivisionError:
-        return "zero"
-    except:
-        return "other"
+  try:
+    return f(x)
+  except TypeError:
+    return "type"
+  except ValueError:
+    return "value"
+  except ZeroDivisionError:
+    return "zero"
+  except:
+    return "other"
 
 print(safe(lambda x: 1 / x, 0))
 print(safe(lambda x: int(x), "abc"))
@@ -229,9 +229,9 @@ Parse but raise `RuntimeError` when executed:
 
 ```python
 try:
-    import os
+  import os
 except RuntimeError as e:
-    print("import:", e)
+  print("import:", e)
 ```
 
 Exist for syntactic compatibility. For code reuse, use higher-order functions.