From 1500d99d7a64e1b3d9f22827b02adf34bed19ce7 Mon Sep 17 00:00:00 2001
From: Adam McDaniel <adam.mcdaniel17@gmail.com>
Date: Sun, 8 Sep 2024 05:53:03 -0400
Subject: [PATCH] Improved web example

---
 CHANGELOG.md | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 210f9e5a..045bfb13 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -185,4 +185,67 @@ println(main());
 The compiler is significantly faster -- about 20 times faster at compiling the AES example.
 This is mainly due to the much faster parser implemented with Nom instead of Pest.
 There are also several optimizations with constant evaluation I added, along with optimizations
-for how declarations are typechecked.
\ No newline at end of file
+for how declarations are typechecked.
+
+
+## [0.1.1-alpha] - 2024-9-8
+
+### Added
+
+Added `const` generics, so constant parameters can be passed along with types through templates. This allows the typechecker to be applied to many more aspects of code, including examples like typechecking dimensions of matrix multiplications at compile time.
+
+```rs
+struct Matrix<T, const Rows: Int, const Cols: Int> {
+    arr: [[T * Cols] * Rows]
+}
+
+impl Matrix<T, Rows, Cols> {
+    fun new(x: T): Matrix<T, Rows, Cols> {
+        return {arr=[[x] * Cols] * Rows};
+    }
+
+    fun get(&self, row: Int, col: Int): &T {
+        return &self.arr[row][col];
+    }
+
+    fun mul<const NewCols: Int>(
+        &self,
+        other: &Matrix<T, Cols, NewCols>,
+        zero: T,
+        add: fun(T, T) -> T,
+        mul: fun(T, T) -> T
+    ): Matrix<T, Rows, NewCols> {
+        let mut result = Matrix.new<T, Rows, NewCols>(zero);
+        for let mut j=0; j<NewCols; j+=1; {
+            for let mut i=0; i<Rows; i+=1; {
+                let mut sum = zero;
+                for let mut k=0; k<Cols; k+=1; {
+                    sum = add(sum, mul(self.arr[i][k], other.arr[k][j]));
+                }
+                result.arr[i][j] = sum;
+            }
+        }
+        result
+    }
+}
+
+let mut x = Matrix.new<Int, 4, 4>(10);
+let mut y = Matrix.new<Int, 4, 4>(5);
+
+println(x);
+println(y);
+
+fun add_ints(a: Int, b: Int): Int = a + b;
+fun mul_ints(a: Int, b: Int): Int = a * b;
+
+let z = y.mul<4>(&x, 0, add_ints, mul_ints);
+println(z);
+```
+
+### Changed
+
+Changed type system to accommodate const generics. This was done by adding a `ConstParam` variant to types.
+
+### Fixed
+
+Improved parser speed by a significant amount during the process.
\ No newline at end of file