nevalang · emil14 · Dec 15, 2024 · Dec 15, 2024 · Dec 16, 2024 · Dec 16, 2024
diff --git a/.cursorrules b/.cursorrules
@@ -1,2 +1,3 @@
+- never remove my comments
 - write comments in lowercase
 - write names for table-driven test-cases in lower_snake_case
diff --git a/.vscode/bookmarks.json b/.vscode/bookmarks.json
@@ -0,0 +1,14 @@
+{
+	"files": [
+		{
+			"path": "internal/compiler/analyzer/nodes.go",
+			"bookmarks": [
+				{
+					"line": 213,
+					"column": 2,
+					"label": ""
+				}
+			]
+		}
+	]
+}
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -7,8 +7,8 @@
       "request": "launch",
       "mode": "auto",
       "program": "${workspaceFolder}/cmd/neva",
-      "cwd": "${workspaceFolder}/e2e/filter_list",
-      "args": ["run", "--trace", "main"]
+      "cwd": "${workspaceFolder}/examples",
+      "args": ["run", "--trace", "unions_tag_only"]
     },
     {
       "name": "DEBUG CODEGEN",

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -10,7 +10,6 @@ Start from reading [ARCHITECTURE.md](./ARCHITECTURE.md) and [Makefile](./Makefil
 - Make: https://www.gnu.org/software/make/#download
 - NodeJS and NPM: https://docs.npmjs.com/downloading-and-installing-node-js-and-npm/
 - Antlr: `pip install antlr4-tools`
-<!-- - Tygo: `go install github.com/gzuidhof/tygo@latest` -->
 
 ### VSCode
 
@@ -29,12 +28,6 @@ Not required but recommended:
 2. If something doesn't work, run `/parser/smoke_test`
 3. To debug deeper, make sure `neva.g4` is opened in the editor and launch VSCode's `ANTLR` debug task
 
-<!-- ## VSCode Extension
-
-VSCode extension depends on types defined in the `sourcecode` and `typesystem` packages so it's dangerous to rename those. If you going to do so, make sure you did't brake TS types generation.
-
-Check out [tygo.yaml](./tygo.yaml). and `CONTRIBUTING.md` in "vscode-neva" repo. -->
-
 ## Learning Resources
 
 ### Dataflow
@@ -168,10 +161,6 @@ Two reasons:
 
 Actually it's impossible to have desugarer before analysis. It's possible to have two desugarers - one before and one after. But that would make compiler much more complicated without visible benefits.
 
-### Why union types are allowed for constants at syntax level?
-
-You indeed can declare `const foo int | string = 42` and that won't make much sense. The problem it's not enough to restrict that at root level, you also have to recursively check every complex type like `struct`, `list` or `map`. And that is impossible to make at syntax level and require work in analyzer. This is could be done in the future when we cover more important cases.
-
 ### Why we have special syntax for union?
 
 We don't have sugar for `maybe<T>` and `list<T>` so why would we have this for unions? The reason is union is special for the type system. It's handled differently at the level of compatibility checking and resolving.

diff --git a/README.md b/README.md
@@ -11,21 +11,23 @@
 </p>
 
 <div align="center">
-  Next-generation programming language that solves programmer's problems
+  Next-generation programming language that solves programmers' problems
 </div>
 <br/>
 
+![tests](https://github.com/nevalang/neva/actions/workflows/test.yml/badge.svg?branch=main) ![lint](https://github.com/nevalang/neva/actions/workflows/lint.yml/badge.svg?branch=main) [![go report](https://goreportcard.com/badge/github.com/nevalang/neva)](https://goreportcard.com/report/github.com/nevalang/neva) [![Discord](https://img.shields.io/discord/1094102475927203921?logo=discord&logoColor=white&color=5865F2)](https://discord.gg/dmXbC79UuH) [![ChatGPT](https://img.shields.io/badge/Nevalang_AI-74aa9c?logo=openai&logoColor=white)](https://chatgpt.com/g/g-RhZn00MXU-nevalang-expert) ![OS](https://img.shields.io/badge/os-windows%20%7C%20macos%20%7C%20linux-lightgrey?logo=linux&logoColor=white) ![Go](https://img.shields.io/badge/v1.23-00ADD8?logo=go&logoColor=white) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 [**Documentation**](./docs/README.md)
 | [**Examples**](./examples/)
 | [**Community**](#-community)
 | [**Releases**](https://github.com/nevalang/neva/releases)
 | [**Contributing**](./CONTRIBUTING.md)
 | [**Architecture**](./ARCHITECTURE.md)
 
-![tests](https://github.com/nevalang/neva/actions/workflows/test.yml/badge.svg?branch=main) ![lint](https://github.com/nevalang/neva/actions/workflows/lint.yml/badge.svg?branch=main)
-
 </div>
 
+> **⚠️ WARNING**: This project is under active development and not yet production-ready!
+
 ## 🤔 What Is Nevalang?
 
 Nevalang is a new kind of programming language where instead of writing step-by-step instructions you create **networks** where data flows between **nodes** as **immutable messages** and everything runs **in parallel by default**. After **type-checking**, your program is compiled into **machine code** and can be distributed as a **single executable** with zero dependencies.
@@ -34,7 +36,15 @@ Combined with built-in **stream processing** support and features like **advance
 
 Future updates will include **visual programming** and **Go interoperability** to allow gradual adoption and leverage existing ecosystem.
 
-> ⚠️ This project is under active development and not yet production-ready.
+### Why Yet Another Programming Language?
+
+We created Nevalang because we saw a gap in the programming language landscape:
+
+1. **Visual Programming Done Right** - While there are many visual programming tools, they're usually limited to specific domains or lack the power of traditional programming. Nevalang is designed from the ground up to be a hybrid visual/text-based programming environment.
+2. **Simple Parallel Programming** - Most languages treat concurrency as an advanced feature, making it complex and error-prone. In Nevalang, parallelism is the default, and the language design prevents common issues like data races.
+3. **Modern Developer Experience** - We combine the best ideas from modern languages with dataflow programming to create a unique development experience focused on productivity.
+
+Finally, we believe exploring new programming paradigms is valuable for the entire programming community, even if only to learn what works and what doesn't.
 
 ## 👋 Hello, World!
 
@@ -48,30 +58,30 @@ def Main(start any) (stop any) {
 }
 ```
 
-What’s happening here:
+What's happening here:
 
 - `import { fmt }` loads the `fmt` package for printing
-- `def Main` defines the main component with input port `start` and output port `stop`
-- `:start -> ‘Hello, World!’ -> println -> :stop` defines a connection that sends `Hello, World!` string to the `println` printer-node and then terminates the program
+- `def Main` defines the main component with input port `start` and output port `stop` of type `any` (it's safe since it's only used as a signal)
+- `:start -> 'Hello, World!' -> println -> :stop` defines a connection that sends the string to `println` when program starts and terminates after printing (runtime sends a message to `Main:start` at startup and waits for `Main:stop` to terminate)
 
 ## 🔥 Features
 
-- 📨 **Dataflow Programming** - Write programs as message-passing graphs
-- 🔀 **Implicit Parallelism** - Everything is parallel by default, no async-await/threads/goroutines/etc.
-- 🛡️ **Strong Static Typing** - Robust type system with generics and pattern-matching
-- 🚀 **Machine Code Compilation** - Compile for any Go-supported platform, including WASM
-- ⚡️ **Stream Processing** - Handle real-time data with streams as first class citizens
-- 🧯 **Advanced Error Handling** - Errors as values with `?` operator to avoid boilerplate
-- 🧩 **Functional Patterns** - Immutability and higher-order components
-- 🔌 **Dependency Injection** - Modularity with interfaces and DI
-- 🪶 **Minimal Core** - Simple language with limited abstractions
-- 📦 **Package Manager** - Publish packages by pushing a git-tag
-- ♻️ **Garbage Collection** - Automatic memory management using Go's low-latency GC
-- 🌈 **Visual Programming** (WIP): Edit programs as visual graphs
-- 🔄 **Go Interoperability** (WIP): Call Go from Neva and Neva from Go
-- 🕵 **NextGen Debugging** (WIP): Observe execution in realtime and intercept messages on the fly
-
-## 🧐 Why Nevalang?
+- **Dataflow Programming** - Write programs as message-passing graphs
+- **Implicit Parallelism** - Everything is parallel by default, no async-await/threads/goroutines/etc.
+- **Strong Static Typing** - Robust type system with generics and pattern-matching
+- **Machine Code Compilation** - Compile for any Go-supported platform, including WASM
+- **Stream Processing** - Handle real-time data with streams as first class citizens
+- **Advanced Error Handling** - Errors as values with `?` operator to avoid boilerplate
+- **Functional Patterns** - Immutability and higher-order components
+- **Dependency Injection** - Modularity with interfaces and DI
+- **Minimal Core** - Simple language with limited abstractions
+- **Package Manager** - Publish packages by pushing a git-tag
+- **Garbage Collection** - Automatic memory management using Go's low-latency GC
+- **Visual Programming** (WIP): Edit programs as visual graphs
+- **Go Interoperability** (WIP): Call Go from Neva and Neva from Go
+- **NextGen Debugging** (WIP): Observe execution in realtime and intercept messages on the fly
+
+## 🧐 Why Use Nevalang?
 
 Let's compare Nevalang with Go. We could compare it to any language but Go is a simple reference since Nevalang is written in Go.
 
@@ -88,32 +98,81 @@ Let's compare Nevalang with Go. We could compare it to any language but Go is a
 | **Dependency Injection** | Built-in - any component with dependency expects injection         | Manual - programmer must create constructor function that takes dependencies      |
 | **Stream Processing**    | Native support with components like `Map/Filter/Reduce`            | Programmer must manually implement dataflow patterns with goroutines and channels |
 
-## 📢 Community
+## 🏭 Architecture
 
-As you can see, this is quite an ambitious project. Typically, such projects are backed by companies, but Nevalang is maintained by a very small group of enthusiasts. Your support by joining us will show interest and motivate us to continue.
+> This is a high-level overview. For a more detailed overview of the architecture, please see [ARCHITECTURE.md](./ARCHITECTURE.md)
 
-- [Discord](https://discord.gg/dmXbC79UuH)
-- [Reddit](https://www.reddit.com/r/nevalang/)
-- [Telegram group](https://t.me/+H1kRClL8ppI1MWJi)
+<div align="center">
 
-### 🙏 Support
+```mermaid
+flowchart LR
+  source_code-->compiler-->|go_code| go_compiler
 
-Please **give us a star ⭐️** to increase our chances of getting into GitHub trends - the more attention Nevalang gets, the higher our chances of actually making a difference.
+  subgraph compiler
+    parser-->analyzer-->backend
+  end
+
+  go_compiler-->machine_code
+  go_compiler-->wasm
+```
+
+</div>
+
+Nevalang compiles to dependency-free, human-readable Go code that uses goroutines and channels for message-passing with parallelism. The Go compiler then produces optimized platform-specific code for any supported platform. This approach gives our programs access to Go's production-grade runtime with an advanced scheduler, garbage collector, and battle-tested standard library. We stand on the shoulders of giants.
+
+## ⭐️ Star History
 
 <p align="center">
-  <img src="./assets/animations/github_star.gif" alt="GitHub Star">
+  <a href="https://star-history.com/#nevalang/neva&Timeline">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=nevalang/neva&type=Timeline&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=nevalang/neva&type=Timeline" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=nevalang/neva&type=Timeline" />
+  </picture>
+  </a>
 </p>
 
 ## 💭 What's Next?
 
+> ℹ️ We take development seriously but have limited time to keep everything current. Feel free to reach out on our social platforms with any questions!
+
 - [Documentation](./docs/README.md) - Install and learn the language basics
 - [Examples](./examples/) - Learn the language by small programs
 
-> Please keep in mind that these resources might not be ready or may be outdated due to the current state of the project. However, rest assured that we take development seriously. We simply don't have enough time to keep everything up to date all the time. Please don't feel intimidated and contact us on our social platforms if you have any questions. We welcome _any_ feedback, no matter what.
+### Community
 
-## 🤝 Contributing
+This is an ambitious project maintained by a small group of enthusiasts. Your support by **joining us** will show interest and motivate us to continue.
+
+[![Discord](https://img.shields.io/badge/Discord-7289DA?logo=discord&logoColor=white)](https://discord.gg/dmXbC79UuH)
+[![Telegram](https://img.shields.io/badge/Telegram-26A5E4?logo=telegram&logoColor=white)](https://t.me/+H1kRClL8ppI1MWJi)
+[![Reddit](https://img.shields.io/badge/Reddit-FF4500?logo=reddit&logoColor=white)](https://www.reddit.com/r/nevalang/)
+[![Twitter](https://img.shields.io/badge/Twitter-000000?logo=x&logoColor=white)](https://x.com/neva_language)
+
+### Contributing
 
 1. See [contributing](./CONTRIBUTING.md) and [architecture](./ARCHITECTURE.md)
 2. Check out [roadmap](https://github.com/nevalang/neva/milestones?direction=asc&sort=due_date&state=open) and [kanban-board](https://github.com/orgs/nevalang/projects/2/views/3?filterQuery=)
 3. Also please read our [CoC](./CODE_OF_CONDUCT.md)
 4. Join [discord server](https://discord.gg/dmXbC79UuH)
+
+### Support
+
+Please **give us a star ⭐️** to increase our chances of getting into GitHub trends - the more attention Nevalang gets, the higher our chances of actually making a difference.
+
+<p align="center">
+  <img src="./assets/animations/github_star.gif" alt="GitHub Star">
+</p>
+
+Please **share this project** with your friends! Every share helps us reach more developers and grow our community. The more developers we reach, the more likely we are to build something truly revolutionary together. 🚀
+
+<div align="center" style="display:grid;place-items:center;">
+
+[![share on x](https://img.shields.io/badge/share-000000?logo=x&logoColor=white)](https://x.com/intent/tweet?text=Check%20out%20Nevalang%20on%20GitHub:%20https://github.com/nevalang/neva%20%23Programming%20%23DataFlow%20%23Concurrency)
+[![share on facebook](https://img.shields.io/badge/share-1877F2?logo=facebook&logoColor=white)](https://www.facebook.com/sharer/sharer.php?u=https://github.com/nevalang/neva)
+[![share on reddit](https://img.shields.io/badge/share-FF4500?logo=reddit&logoColor=white)](https://www.reddit.com/submit?title=Check%20out%20Nevalang%20on%20GitHub:%20https://github.com/nevalang/neva)
+[![share on telegram](https://img.shields.io/badge/share-0088CC?logo=telegram&logoColor=white)](https://t.me/share/url?url=https://github.com/nevalang/neva&text=Check%20out%20Nevalang%20on%20GitHub)
+[![share on whatsapp](https://img.shields.io/badge/share-25D366?logo=whatsapp&logoColor=white)](https://wa.me/?text=Check%20out%20Nevalang%20on%20GitHub:%20https://github.com/nevalang/neva)
+[![share on hackernews](https://img.shields.io/badge/share-F0652F?logo=ycombinator&logoColor=white)](https://news.ycombinator.com/submitlink?u=https://github.com/nevalang/neva&t=Nevalang:%20Next-generation%20programming%20language%20with%20implicit%20parallelism)
+[![share on linkedin](https://img.shields.io/badge/linkedin-share-0A66C2?logo=linkedin&logoColor=white)](https://www.linkedin.com/sharing/share-offsite/?url=https://github.com/nevalang/neva)
+
+</div>
diff --git a/docs/book/program_structure.md b/docs/book/program_structure.md
@@ -36,10 +36,10 @@ Module is usually a git-repo but not necessary. Module that isn't published in g
 
 ### Manifest File
 
-The manifest defines the module's minimum supported language version and dependencies. Here's an example manifest with a dependency on the Nevalang compiler version `0.30.0` and a third-party module:
+The manifest defines the module's minimum supported language version and dependencies. Here's an example manifest with a dependency on the Nevalang compiler version `0.31.0` and a third-party module:
 
 ```yaml
-neva: 0.30.0
+neva: 0.31.0
 deps:
   github.com/nevalang/x:
     path: github.com/nevalang/x
@@ -51,7 +51,7 @@ The `deps` field is a map where each dependency has an alias. When adding depend
 > WIP: CLI tool planned for CI/CD to verify module's backward compatibility
 
 ```yaml
-neva: 0.30.0
+neva: 0.31.0
 deps:
   github.com/nevalang/x@0-0-12:
     path: github.com/nevalang/x

diff --git a/docs/tutorial.md b/docs/tutorial.md
@@ -77,7 +77,7 @@ After installation is finished, you should be able to run the `neva` CLI from yo
 neva version
 ```
 
-It should emit something like `0.30.0`
+It should emit something like `0.31.0`
 
 ### Hello, World!
 
@@ -256,7 +256,7 @@ This structure introduces two fundamental concepts in Nevalang: modules and pack
 A module is a set of packages with a manifest file (`neva.yaml`). When we created our project with `neva new`, it generated a basic module with the following manifest file:
 
 ```yaml
-neva: 0.30.0
+neva: 0.31.0
 ```
 
 This defines the Nevalang version for our project. As your project grows, you can include dependencies on third-party modules here.

diff --git a/e2e/99_bottles_verbose/main/main.neva b/e2e/99_bottles_verbose/main/main.neva
@@ -1,4 +1,7 @@
-import { fmt }
+import {
+    fmt
+    runtime
+}
 
 // https://www.99-bottles-of-beer.net
 
@@ -40,7 +43,7 @@ def PrintFirstLine(n int) (n int) {
     p2 fmt.Println
     printf fmt.Printf
     lock Lock<int>
-    panic Panic
+    panic runtime.Panic
     ---
     :n -> [s:data, lock:data]
 
@@ -73,7 +76,7 @@ def PrintSecondLine(n int) (n int) {
     p3 fmt.Println
     printf fmt.Printf
     lock Lock<int>
-    panic Panic
+    panic runtime.Panic
     ---
     :n -> [s:data, lock:data]
 

diff --git a/e2e/99_bottles_verbose/neva.yml b/e2e/99_bottles_verbose/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/add_nums_from_stdin_naive/main/main.neva b/e2e/add_nums_from_stdin_naive/main/main.neva
@@ -1,4 +1,8 @@
-import { strconv, fmt }
+import {
+    fmt
+    runtime
+    strconv
+}
 
 def Main(start any) (stop any) {
 	scanner1 fmt.Scanln
@@ -7,7 +11,7 @@ def Main(start any) (stop any) {
 	parser2 strconv.ParseNum<int>
 	add Add<int>
 	println fmt.Println<int>
-	panic Panic
+	panic runtime.Panic
 	---
 	:start -> scanner1:sig
 	scanner1:res -> parser1:data

diff --git a/e2e/add_nums_from_stdin_naive/neva.yml b/e2e/add_nums_from_stdin_naive/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/add_nums_from_stdin_with_default_any/main/main.neva b/e2e/add_nums_from_stdin_with_default_any/main/main.neva
@@ -1,9 +1,13 @@
-import { strconv, fmt }
+import {
+    fmt
+    runtime
+    strconv
+}
 
 def Main(start any) (stop any) {
 	aux Aux
 	println fmt.Println
-	panic Panic
+	panic runtime.Panic
 	---
 	:start -> aux:sig
 	aux:res -> println:data

diff --git a/e2e/add_nums_from_stdin_with_default_any/neva.yml b/e2e/add_nums_from_stdin_with_default_any/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/add_nums_from_stdin_with_err_handling/neva.yml b/e2e/add_nums_from_stdin_with_err_handling/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/add_nums_from_stdin_with_multuple_senders/neva.yml b/e2e/add_nums_from_stdin_with_multuple_senders/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/add_nums_from_stdin_with_sub_components/neva.yml b/e2e/add_nums_from_stdin_with_sub_components/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/add_nums_verbose/neva.yml b/e2e/add_nums_verbose/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/array_inport_holes/neva.yml b/e2e/array_inport_holes/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0
diff --git a/e2e/array_outport_holes/neva.yml b/e2e/array_outport_holes/neva.yml
@@ -1 +1 @@
-neva: 0.30.0
+neva: 0.31.0