Release: 1.3.7

Author: ahfriedman

src/SUMMARY.md

@@ -35,6 +35,7 @@
 
 # Changelog
 - [Changelog](./changelog.md)
+    - [V1.3.6](./changelog/1.3.7.md)
     - [V1.3.6](./changelog/1.3.6.md)
     - [V1.3.5](./changelog/1.3.5.md)
 	- [v1.3.4](./changelog/1.3.4.md)

src/changelog.md

@@ -4,6 +4,7 @@
 
 | Version | Links | Date |
 |---------|-------|------|
+| `1.3.7` | [changelog](./changelog/1.3.7.md) \| [github](https://github.com/bismuthlang/bismuth/releases/tag/v1.3.7) | 2025-02-09 | 
 | `1.3.6` | [changelog](./changelog/1.3.6.md) \| [github](https://github.com/bismuthlang/bismuth/releases/tag/v1.3.6) | 2025-01-03 | 
 | `1.3.5` | [changelog](./changelog/1.3.5.md) \| [github](https://github.com/bismuthlang/bismuth/releases/tag/v1.3.5) | 2024-12-22 |  
 | `1.3.4` | [changelog](./changelog/1.3.4.md) \| [github](https://github.com/ahfriedman/bismuth/releases/tag/v1.3.4) \| [gitea](https://gitea.ahfriedman.com/ahf/prism/releases/tag/v1.3.4) | 2024-05-03 |

src/changelog/1.3.7.md

@@ -0,0 +1,16 @@
+# 1.3.7 (Pre-Alpha) - 2025-02-09
+
+## BREAKING 
+  - Entry point changed from `program` to `main`
+
+## Features
+  - Syntax improvements: removed the `define` keyword, added `prog` keyword, and now specification of `Channel` in programs is implicit
+  - Added in "error-flows" which allows error messages to be displayed in a tree to get a better sense of how an error originated
+
+## Bugs
+  - Improved nix flake build stability
+
+## Compiler Internals
+  - Refactored various visitors
+  - Improved some error messages
+

src/ref/Misc.md

@@ -22,9 +22,9 @@ var b := false; // b will be inferred as having type bool
 var c := exec Program<P>; // c will be inferred as having type Channel<dual P> 
 ```
 
-## asChannel(e : T[]) : Channel<!+T> {.code .mb-0}
-## asChannel(e : T[N}) : Channel<!+T> {.code .m-0}
-## asChannel(e : T) : Channel<!+T> {.code .m-0}
+## asChannel(e : T[]) -> Channel<!+T> {.code .mb-0}
+## asChannel(e : T[N}) -> Channel<!+T> {.code .m-0}
+## asChannel(e : T) -> Channel<!+T> {.code .m-0}
 * Since: `1.3.4` 
 Given an expression `e`, `asChannel` will evaluate it and return the reuslts as a channel that can be iterated through. 
 
@@ -42,7 +42,7 @@ accept(c2){
 printf("\n");
 ```
 
-## copy(e : T) : T {.code} 
+## copy(e : T) -> T {.code} 
 Given any non-linear expression `e`, `copy` will return a deep copy of the expression. Note: parenthesis around the expression to be copied are optional. 
 
 Example: 
@@ -55,7 +55,7 @@ var ptr := Box<int>::init(a);
 var c := copy ptr; // c will be a deep copy of ptr
 ```
 
-## extern \<Identifier\> (T_1, ... T_n) : T_r {.code}
+## extern \<Identifier\> (T_1, ... T_n) -> T_r {.code}
 
 Allows one to import a function from another file/the C standard library whose name is `<Identifier>`, has the return type `T_r`, and has the arguments `T_1, ..., T_n`. This function is likely to be deprecated in favor of an easier system for importing resources—including other types (e.g., programs, structs, enums, etc).  
 

src/ref/types/Box.md

@@ -4,7 +4,7 @@ Boxes represent a pointer to data of a specified type, `T`, that is being stored
 
 ## Functions
 
-### Box\<T\>::init(e : T) : Box\<T\> {.code} 
+### Box\<T\>::init(e : T) -> Box\<T\> {.code} 
 
 Creates a new value of type `Box<T>` by storing the result of evaluating the expression `e : T`. 
 

src/ref/types/Channel.md

@@ -3,33 +3,33 @@ Channels allow asynchronous type-safe communication between two processes. Chann
 
 ## Functions
 
-### self.send(e : T) : Unit {.code}
+### self.send(e : T) -> Unit {.code}
 * Given: `self : -T;P`
 * Action: Sends the result of evaluating expression `e : T` to the remote process. If `e` is linear, the sent value will be copied. If it is non-linear, then the value will be moved to the remote process.
 * Result: `self : P`
 
-### self.recv() :  T {.code}
+### self.recv() ->  T {.code}
 * Given: `self : +T;P`
 * Action: Receives a value of type `T` from the remote processs.
 * Result: `self : P`
 
-### unfold(self) : Unit {.code}
+### unfold(self) -> Unit {.code}
 * Given: `self : ?P_1;P_2`
 * Action: Unfolds an interation of `P_1` from `?P_1`. 
 * Result: `self : P_1;?P_1;P_2`
 
-### unfold(self) : Unit {.code}
+### unfold(self) -> Unit {.code}
 * Given: `self : *?P_1;P_2`
 * Action: Unfolds an interation of `P_1` from `*?P_1` (`P_1` is guarded). 
 * Result: `self : P_1;*?P_1;P_2`
 
-### more(self) : Unit {.code}
+### more(self) -> Unit {.code}
 *Deprecated; See unfold.*
 
-### more(self) : Unit {.code}
+### more(self) -> Unit {.code}
 *Deprecated; See unfold.*
 
-### weaken(self) : Unit {.code}
+### weaken(self) -> Unit {.code}
 * Given: `self : ?P_1T;P_2`
 * Action: Finishes loop `?P_1`. 
 * Result: `self : P_2`
@@ -45,7 +45,7 @@ Channels allow asynchronous type-safe communication between two processes. Chann
 * Result: `self : P_i`
 
 
-### self.cancel() : Unit {.code}
+### self.cancel() -> Unit {.code}
 * Since: `1.3.4`
 * Given: `self : Cancelable<...Cancelable<P_1>;P_2>;P_3`
 * Action: Cancels (skips over) the innermost session type

src/ref/types/Program.md

@@ -8,7 +8,7 @@ Currently programs also serve as the main entrypoint to a bismuth program. Speci
 
 Programs are currently defined using the following syntax: 
 ```bismuth 
-define <NAME> :: <CHANNEL ID> : Channel<<SESSION TYPE>> {
+prog <NAME> :: <CHANNEL ID> : <SESSION TYPE> {
    // Code 
 }
 ```
@@ -17,7 +17,8 @@ In this syntax, `<NAME>` represents the name of the program, `<CHANNEL ID>` is t
 For example consider the following program: 
 
 ```bismuth
-define foo :: c : Channel<-int> {
+prog foo :: c : -int {
+  # c : Channel<-int>
   c.send(0); 
 }
 ```

src/ref/types/enum.md

@@ -10,7 +10,7 @@ Enums can either be anonymous (defined in-place) or named. Anonymous enums are d
 
 Named enums are defined using the following syntax: 
 ```bismuth 
-define enum <NAME> {
+enum <NAME> {
     T_1, 
     ..., 
     T_n
@@ -20,9 +20,9 @@ define enum <NAME> {
 Unlike anonymous enums which are equivalent based on the types they can contain, named enums are seen as equal based on instance of the defined type. For example: 
 
 ```bismuth
-define enum Foo { int, boolean }
+enum Foo { int, boolean }
 
-define enum Bar { int, boolean } 
+enum Bar { int, boolean } 
 
 Foo f := 5; 
 Bar b := 5; 

src/ref/types/func.md

@@ -7,24 +7,24 @@ Functions are synchronous snippets of code that can take parameters and return a
 Functions can either be anonymous (defined in-place) or named. Anonymous funcs are defined using the syntax where `T_i` represents the type of the ith parameter which is named `N_n`, `T_r` is the type of data returnd by the function, and the code between the `{}` braces defines the body of the function:
 
 ```bismuth 
-(T_1 N_1, ... , T_n N_n) : T_r {...}
+(T_1 N_1, ... , T_n N_n) -> T_r {...}
 ```
 
 For example, an anonymous function to square a number could be defined as follows: 
 ```bismuth
-(int i) : int { return i * i; }
+(int i) -> int { return i * i; }
 ```
 
 Functions can be stored as values or called in-line with their anonymous definition as shown below: 
 ```bismuth 
-(int) -> int square := (int i) : int { return i * i; }
-int result1 := (int i) : int { return i * i; }(2); // 4
+(int) -> int square := (int i) -> int { return i * i; }
+int result1 := (int i) -> int { return i * i; }(2); // 4
 int result2 := square(2); // 4
 ```
 
 Functions can also be defined with a name to enable recursive use: 
 ```bismuth 
-define func fib(int n) : int {
+func fib(int n) -> int {
   if(n == 0 | n == 1) {
     return n;
   }

src/ref/types/struct.md

@@ -6,7 +6,7 @@ Structs (AKA. Product types) respresent a type of data which stores a value that
 
 Structs are defined using the following syntax where `T_i` represents the type of the data stored by the field labeled by `N_i`: 
 ```bismuth 
-define enum <NAME> {
+enum <NAME> {
     T_1 N_1;  
     ..., 
     T_n N_n; 
@@ -15,7 +15,7 @@ define enum <NAME> {
 
 For example, a linked list of integers could be defined as follows: 
 ```bismuth 
-define enum ListNode {
+enum ListNode {
     int value; 
     (Unit + Box<ListNode>) next; 
 }