Channels, fibers, oh my!

README.md

@@ -2,41 +2,48 @@
 
 A sweet programming language that is robust, minimalistic, and expressive.
 
-Candy aims to have excellent tooling – most language features are designed with tooling in mind.
+Candy aims to have excellent tooling – most language features are designed with tooling in mind.
 Many languages have a strict separation between compile-time and runtime.
 Candy blurs the line between those stages, for example, by replacing compile-time types with edit-time fuzzing.
 
 ## Quick introduction
 
-* **Values are at the center of your computations.**
+- **Values are at the center of your computations.**
   Only a handful of predefined types of values exist:
-  ```
+
+  ```candy
   3                   # int
   "Candy"             # text
   Green               # symbol
   [ Name: "Candy" ]   # struct
   { it -> add it 2 }  # closure
   ```
-* **Minimalistic syntax.**
+
+- **Minimalistic syntax.**
   Defining variables and functions works without braces or keywords cluttering up your code.
   The syntax is indentation-aware.
-  ```
+
+  ```candy
   foo = 42
   println message =
     print message
     print "\n"
   println "Hello, world!"
   ```
-* **Extensive compile-time evaluation.**
+
+- **Extensive compile-time evaluation.**
   Many values can already be computed at compile-time.
   In your editor, you'll see the results on the right side:
-  ```
+
+  ```candy
   foo = double 2  # foo = 4
   ```
-* **Fuzzing instead of traditional types.**
-  In Candy, functions have to specify their needs *exactly.*
+
+- **Fuzzing instead of traditional types.**
+  In Candy, functions have to specify their needs _exactly._
   As you type, the tooling automatically tests your code with many input to see if one breaks the code:
-  ```
+
+  ```candy
   foo a =             # If you pass a = 0,
     needs (isInt a)
     math.logarithm a  # then this fails because logarithm only works on positive numbers.
@@ -61,63 +68,74 @@ To get a more in-depth introduction, read the [language document](language.md).
 We are currently implementing a first version of Candy in Rust.
 We already have a language server that provides some tooling.
 
-Major milestones:
-
-* [x] build a basic parser
-* [x] lower CST to AST
-* [x] lower AST to HIR
-* [x] build a basic interpreter
-* [x] add CLI arguments for printing the CST, AST, or HIR
-* [ ] make functions independent of their order in top-level scope
-* [x] support importing other files (`use`)
-* [x] namespaces/modules including visibility modifiers
-* [ ] IDE support:
-  * [ ] completion, completion resolve
-  * [ ] hover
-  * [ ] signatureHelp
-  * [x] ~~declaration~~, definition, ~~typeDefinition~~
-  * [ ] implementation
-  * [x] references
-  * [x] documentHighlight
-  * [ ] documentSymbol
-  * [ ] codeAction, codeAction resolve
-  * [ ] codeLens, codeLens resolve, codeLens refresh
-  * [ ] documentLink, documentLink resolve
-  * [x] ~~documentColor, colorPresentation~~
-  * [ ] formatting
-  * [ ] rangeFormatting
-  * [ ] onTypeFormatting
-  * [ ] rename, prepareRename
-  * [x] foldingRange
-  * [ ] selectionRange
-  * [ ] prepareCallHierarchy
-  * [ ] callHierarchy incoming, callHierarchy outgoing
-  * [x] semantic tokens
-  * [x] ~~linkedEditingRange~~
-  * [ ] moniker
-* [x] incremental compilation
-* [ ] lists
-* [x] structs
-* [ ] sets
-* [ ] text interpolation
-* [x] constant evaluation
-* [ ] fibers
-* [ ] channels
-* [ ] io
-* [ ] random
-* [ ] standard library
-* [ ] pipe operator
-* [x] auto-fuzzing
-* [ ] "type" proofs
-* [ ] testing
-* [ ] fuzzing of the compiler itself
-* [ ] clean up repo (delete a bunch of stuff!)
-* [ ] package manager
-* [ ] online playground
+## Long-term TODOs
+
+- Core
+  - io
+  - random
+  - timing
+  - environment variables
+  - HTTP, UDP
+- compiler
+  - make functions independent of their order in top-level scope
+  - lists
+  - text interpolation
+  - fibers, channels
+  - patterns
+  - pipe operator
+  - "type" proofs
+  - fuzzing of the compiler itself
+  - package root marker
+  - package path dependencies
+  - performance
+    - multithreading
+    - object deduplication
+    - profiler
+    - memory representation
+      - inlining of ints/etc.
+      - size of an object
+      - heap management
+  - LLVM, WASM
+- IDE support:
+  - generate debug files
+  - [ ] completion, completion resolve
+  - [ ] hover
+  - [ ] signatureHelp
+  - [x] ~~declaration~~, definition, ~~typeDefinition~~
+  - [ ] implementation
+  - [x] references
+  - [x] documentHighlight
+  - [ ] documentSymbol
+  - [ ] codeAction, codeAction resolve
+  - [ ] codeLens, codeLens resolve, codeLens refresh
+  - [ ] documentLink, documentLink resolve
+  - [x] ~~documentColor, colorPresentation~~
+  - [ ] formatting
+  - [ ] rangeFormatting
+  - [ ] onTypeFormatting
+  - [ ] rename, prepareRename
+  - [x] foldingRange
+  - [ ] selectionRange
+  - [ ] prepareCallHierarchy
+  - [ ] callHierarchy incoming, callHierarchy outgoing
+  - [x] semantic tokens
+  - [x] ~~linkedEditingRange~~
+  - [ ] moniker
+- packages
+  - logging
+  - HTTP Server
+  - Markdown
+  - custom binary serialization
+  - Cap'n Proto
+  - DateTime?
+  - SI?
+  - MongoDB?
+  - package manager
+- online playground
+- clean up repo (delete a bunch of stuff!)
 
 ## Short-term TODOs
 
-- casing of module names
 - fix fault attribution
 - rearchitect tracing
 - new name?
@@ -137,7 +155,6 @@ Major milestones:
 - distinguish packages from normal modules
 - complain about comment lines with too much indentation
 - develop guidelines about how to format reasons
-- module files: `.candy` vs `_.candy`?
 
 ## How to use Candy
 

compiler/Cargo.toml

@@ -36,6 +36,7 @@ tower-lsp = "0.17.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2.0", features = ["registry"] }
 unicode-segmentation = "1.9.0"
+url = "2.2.2"
 
 [target.x86_64-unknown-linux-gnu]
 linker = "/usr/bin/clang"

compiler/src/compiler/README.md

@@ -12,5 +12,5 @@ These are the compiler stages:
 * LIR ("Low-level Intermediate Representation"): An instruction code for a stack-based virtual machine.
 
 Note that if an error occurs in a compilation stage, we don't immediately abort but rather just try to contain the error in a subtree of the code and emit an error node.
-This means that even if you have a syntax error (missing parentheses, etc.), the tooling in other parts of the source still works – including autocompletion, edit-time evaluation, formatting, etc.
+This means that even if you have a syntax error (missing parentheses, etc.), the tooling in other parts of the source still works – including auto-completion, edit-time evaluation, formatting, etc.
 You can even *run* the code – it will simply panic during runtime if it encounters the part with the syntax error.

compiler/src/compiler/comment/mod.rs

@@ -0,0 +1,2 @@
+pub mod rcst;
+pub mod string_to_rcst;