chore: some touchup for typing and patterns

Signed-off-by: Henry Schreiner <henryschreineriii@gmail.com>

Author: henryiii

content/week06/integrator_example/integrator/__init__.py

@@ -2,6 +2,13 @@
 import abc
 
 
+__all__ = ["EulerIntegrator", "RK4Integrator"]
+
+
+def __dir__():
+    return __all__
+
+
 class IntegratorBase(abc.ABC):
     @abc.abstractmethod
     def compute_step(self, f, t_n, y_n, h):

content/week06/introoo.md

@@ -198,6 +198,41 @@ impl Path {
 }
 ```
 ````
+````{tab-item} Swift
+```swift
+import Foundation
+
+class Path {
+    let stringLocation: String
+
+    init(stringLocation: String) {
+        self.stringLocation = stringLocation
+    }
+
+    func exists() -> Bool {
+        return FileManager.default.fileExists(atPath: stringLocation)
+    }
+}
+```
+````
+````{tab-item} Go
+```go
+import "os"
+
+type Path struct {
+	stringLocation string
+}
+
+func NewPath(stringLocation string) *Path {
+	return &Path{stringLocation: stringLocation}
+}
+
+func (p *Path) Exists() bool {
+	_, err := os.Stat(p.stringLocation)
+	return !os.IsNotExist(err)
+}
+```
+````
 `````
 
 This gives us several benefits: If we get a Path, we know it has

content/week07/designpatt.md

@@ -845,12 +845,14 @@ We didn't cover every pattern (and we can't), so here are a few more you can
 look up if you are curious:
 
 - Singleton pattern: There can only be one instance of a class. `None`, `True`,
-  and `False` are singletons in Python.
-- Registries: `logging` uses this design.
+  and `False` are singletons in Python. There are several ways to achieve these.
+- Registries: `logging` uses this design. You collect a global dict of instances
+  and can access them by name.
 - State machine: this is used heavily by Matlab, and sometimes is seen in things
-  mimicking it, like matplotlib's "easy" interface.
+  mimicking it, like matplotlib's "easy" interface. You track which item is
+  "active". Bad for multithreaded environments.
 - Factory pattern: We've touched on this lightly, classes `__init__` method, for
   example. You can have other factories with `@classmethod`'s that return new
-  instances. (or static methods in C++, etc)
+  instances. (or static methods in C++, etc).
 - Ascync patterns: Lightly touched on during generators.
 - Event loop: A common pattern for reacting to multiple possible inputs.

content/week07/functional.md

@@ -312,8 +312,8 @@ int main() {
     std::vector<int> items {1, 2, 3, 4, 5};
     auto odd_sq = items | std::views::transform([](int i){return i*i;})
                         | std::views::filter([](int i){return i%2==1;});
-    sum_sq_odds = std::accumulate(std::begin(odd_sq), std::end(odd_sq), 0, [](int a, int b){return a + b;})
-    std::cout << result << std::endl;
+    auto sum_sq_odds = std::accumulate(std::begin(odd_sq), std::end(odd_sq), 0, [](int a, int b){return a + b;})
+    std::cout << sum_sq_odds << std::endl;
     return 0;
 }
 ```
@@ -322,6 +322,23 @@ Not that C++ is slowly gaining support; `std::fold_left` is in C++23, but for
 C++20, we have to drop back to a classic `std::accumulate` algorithm & begin
 and end iterators.
 
+````
+````{tab-item} C++23 Ranges
+```cpp
+import std;
+
+int main() {
+    std::vector items {1, 2, 3, 4, 5};
+    auto odd_sq = items | std::views::transform([](int i){return i*i;})
+                        | std::views::filter([](int i){return i%2==1;});
+    auto sum_sq_odds = std::ranges::fold_left(odd_sq, 0, [](int a, int b){return a + b;});
+    std::println("{}", sum_sq_odds);
+    return 0;
+}
+```
+
+Not that stdlib module support is not available yet.
+
 ````
 ````{tab-item} Rust
 ```rust
@@ -335,6 +352,16 @@ fn main() {
 }
 ```
 ````
+
+````{tab-item} Swift
+```swift
+let items = [1, 2, 3, 4, 5]
+let sum_sq_odds = items.map { $0 * $0 }
+                       .filter { $0 % 2 == 1 }
+                       .reduce(0, +)
+print(sum_sq_odds)
+```
+````
 `````
 
 Notice how many of the languages use similar terms and try to read well when
@@ -516,3 +543,7 @@ Numba library, which is imperative. PyTorch is a great ML-focused library. CuPy
 is a great GPU NumPy replacement. Etc. JAX here is just intended to be an
 example of what thinking in a functional mindset can do.
 ```
+
+```
+
+```

content/week08/typing.md

@@ -176,7 +176,7 @@ If a file starts with:
 from __future__ import annotations
 ```
 Then all type annotations in the file will be unevaluated strings. This means
-you can use Python 3.13 syntax in them, and even Python 3.7 will happily work!
+you can use Python 3.13 syntax in them, and any Python 3.7+ will happily work!
 This is great, as every version up to 3.10 has had large improvements for
 typing.  We will use the new syntax exclusively; add the above import to follow
 along on older Python versions.
@@ -249,7 +249,7 @@ general, you should be more strict with typing than with runtime.
 Type annotations can appear in any of the following locations:
 
 ```python
-# Variable annotation (3.6+)
+# Variable annotation
 x: int = 2
 
 # No assignment is allowed ("declaration")
@@ -965,7 +965,7 @@ even if `from __future__ import annotations` is used, since it's new syntax and
 not an annotation.
 
 `````{tab-set}
-````{tab-item} Python 3.6+
+````{tab-item} Python <3.12
 ```python
 from typing import TypeVar
 
@@ -976,7 +976,7 @@ def f(x: T) -> T:
     return x
 ```
 ````
-````{tab-item} Python 3.12+
+````{tab-item} Python >=3.12
 ```python
 def f[T](x: T) -> T:
     return x

slides/week-07-1.md

@@ -289,17 +289,17 @@ fn main() {
 
 ---
 
-## Other languages: C++23 (not supported yet)
+## Other languages: C++23 (modules not supported yet)
 
 ```cpp
 import std;
 
 int main() {
     std::vector items {1, 2, 3, 4, 5};
-    auto result = items | std::views::transform([](int i){return i*i;})
+    auto odd_sq = items | std::views::transform([](int i){return i*i;})
                         | std::views::filter([](int i){return i%2==1;});
-    sum_sq_odds = std::fold_left(odd_sq, 0, [](int a, int b){return a + b;});
-    std::println("{}", result);
+    auto sum_sq_odds = std::fold_left(odd_sq, 0, [](int a, int b){return a + b;});
+    std::println("{}", sum_sq_odds);
     return 0;
 }
 ```