Voyd Rename

.gitattributes

@@ -1 +1 @@
-*.void linguist-language=Swift
+*.voyd linguist-language=Swift

.gitignore

@@ -4,6 +4,6 @@ ast.json
 *output*.json
 *output*.wat
 .env
-test.void
+test.voyd
 /playground.*
 /playground

.vscode/settings.json

@@ -47,7 +47,7 @@
     "cSpell.advanced.feature.useReferenceProviderWithRename": true,
     "cSpell.advanced.feature.useReferenceProviderRemove": "/^#+\\s/"
   },
-  "[void]": {
+  "[voyd]": {
     "editor.tabSize": 2
   },
   "vitest.nodeExecutable": ""

README.md

@@ -1,6 +1,6 @@
-# Void
+# Voyd
 
-Void is a high performance WebAssembly language with an emphasis on full stack web development.
+Voyd is a high performance WebAssembly language with an emphasis on full stack web development.
 
 https://justforfunnoreally.dev/
 
@@ -29,7 +29,7 @@ fn app() -> JSX::Element
 
 **Disclaimer**
 
-Void is in it's very early stages of development. Void is not ready for public
+Voyd is in it's very early stages of development. Voyd is not ready for public
 announcement or use. Some core syntax and semantics are subject to change.
 Expect frequent breaking changes. In addition, many documented features are not
 yet implemented.
@@ -60,13 +60,13 @@ yet implemented.
 **Install**
 
 ```
-npm i -g voidc
+npm i -g voydc
 ```
 
 **Usage**
 
 ```
-voidc path/to/code.void
+voydc path/to/code.voyd
 ```
 
 **Requirements**
@@ -130,7 +130,7 @@ To call a function, use the function name followed by the arguments in parenthes
 add(1, 2)
 ```
 
-Void also supports uniform function call syntax (UFCS), allowing functions to be called on a type as if they were methods of that type.
+Voyd also supports uniform function call syntax (UFCS), allowing functions to be called on a type as if they were methods of that type.
 
 ```rust
 1.add(2)

docs/README.md

@@ -1,3 +1,3 @@
-# Void Language Maintainer Docs
+# Voyd Language Maintainer Docs
 
-Docs intended for maintainers of the void language
+Docs intended for maintainers of the voyd language

docs/notes/devlog.md

@@ -46,7 +46,7 @@ brought to the fact that a function is an effect?
 
 Background, given:
 ```
-// src/throws.void
+// src/throws.voyd
 effect State<T>
   ctl set(val: T) -> T
   ctl get() -> T
@@ -131,7 +131,7 @@ Effect system implementation ideas:
 
 ```ts
 type Get = () => number;
-type Put = (value: number) => void;
+type Put = (value: number) => voyd;
 
 const loop = (n: number) => {
   if (n === 0) return;
@@ -148,7 +148,7 @@ const put = (value, state, continuation) =>
 const loop2 = (
   n: number,
   state: { value: number },
-  continuation: (state: { value: number }) => void
+  continuation: (state: { value: number }) => voyd
 ) => {
   if (n === 0) return continuation(state, undefined);
 
@@ -182,11 +182,11 @@ Ideal features:
 - Supports ES Module Syntax natively?
 - Handles function overloads cleanly
 - Still easily supports WASM and potentially other sources while still providing a good DX
-- A `module.void` format for configuration and exports etc
+- A `module.voyd` format for configuration and exports etc
 
 Open questions:
 
-- Void supports _both_ named parameters _and_ objects and treats each one differently. How should
+- Voyd supports _both_ named parameters _and_ objects and treats each one differently. How should
   this be handled? The best I can think of is that named parameters should be treated as objects
 - Need to define a standard for tagged data structures.
 
@@ -197,7 +197,7 @@ Open questions:
 1. (Unchanged) Any line with more than one symbol is wrapped with parenthesis (if it does not
    already have them)
 
-   ```void
+   ```voyd
    add 1 2
 
    // Becomes
@@ -211,7 +211,7 @@ Open questions:
    2. The first child is not a named argument
    3. The parent is not wrapped in parenthesis
 
-   ```void
+   ```voyd
    add 2
      mul 4 x
 

docs/notes/language-benefits.md

@@ -74,5 +74,5 @@ export class Parameter extends NamedEntity {
 }
 ```
 
-Void avoids this common error as the constructor / init function
+Voyd avoyds this common error as the constructor / init function
 is not defined by the user. This problem still exists on overloaded initializers

docs/structural-subtyping.md

@@ -1,6 +1,6 @@
 
 Context:
-```void
+```voyd
 obj A {
   x: i32
 }
@@ -24,7 +24,7 @@ fn main() -> i32
 ```
 
 Implementation (Psuedo VOID / WASM hybrid):
-```void
+```voyd
 // All objects implicitly extend Object
 type Object = {
   // All objects that can be used to access a member of an the object.

package.json

@@ -1,5 +1,5 @@
 {
-  "name": "voidc",
+  "name": "voyd",
   "version": "0.6.0",
   "description": "",
   "module": "dist/index.js",
@@ -13,8 +13,7 @@
     "prepublishOnly": "tsc"
   },
   "bin": {
-    "voidc": "./dist/cli/cli.js",
-    "void": "./dist/cli/cli.js",
+    "voyd": "./dist/cli/cli.js",
     "vt": "./src/cli/cli-dev.ts"
   },
   "keywords": [],

reference/basics.md

@@ -1,14 +1,14 @@
 # Comments
 
-```void
+```voyd
 // This is a single line comment
 ```
 # Identifiers
 
 Identifiers bind names to values, types, and other language constructs. They can
 contain letters, numbers, and underscores, and must start with a letter or underscore.
 
-```void
+```voyd
 hey
 hey_there
 MyType
@@ -17,7 +17,7 @@ MyType2
 
 # Variables
 
-```void
+```voyd
 // Declare an immutable variable
 let x = 5
 
@@ -27,7 +27,7 @@ var y = 3
 
 # String Literals
 
-```void
+```voyd
 // Strings are defined with double quotes
 let name = "John"
 
@@ -42,7 +42,7 @@ let greeting = "Hello, ${name}"
 
 # Numeric Literals
 
-```void
+```voyd
 // Integers
 let x = 5
 
@@ -52,14 +52,14 @@ let y = 3.14
 
 # Boolean Literals
 
-```void
+```voyd
 let x = true
 let y = false
 ```
 
 # Object literals
 
-```void
+```voyd
 let value = {
   a: 5,
   b: 4
@@ -70,7 +70,7 @@ let x = value.a // x will be bound to 5
 
 Field shorthand:
 
-```void
+```voyd
 let a = 5
 let value = { a, b: 4 }
 
@@ -80,7 +80,7 @@ let value = { a: a, b: 4 }
 
 # Tuple literals
 
-```void
+```voyd
 let value = (5, 4)
 let x = value.0 // x will be bound to 5
 
@@ -90,7 +90,7 @@ let (a, b) = value
 
 # Control Flow
 
-```void
+```voyd
 // If statements
 if x > 5 then:
   // Do something
@@ -130,17 +130,17 @@ let y =
 
 Expressions are statements that return a value. They can be used in a variety of contexts, such as variable assignment, function arguments, and more.
 
-```void
+```voyd
 // Binary expressions
 let x = 5 + 3
 
 // Function calls
 let y = add(5, 3)
 ```
 
-Virtually every statement in Void is an expression, including control flow statements.
+Virtually every statement in Voyd is an expression, including control flow statements.
 
-```void
+```voyd
 let x = if true then: 1 else: 2
 
 // Blocks are also expressions, returning the result of the last statement

reference/control-flow.md

@@ -12,7 +12,7 @@ fn match<T extends Object, U>(val: T, bind_identifier: Identifier, body: MatchBl
 ```
 
 Example:
-```void
+```voyd
 obj Optional
 
 obj None extends Optional
@@ -37,7 +37,7 @@ fn main(a: i32, b: i32) -> String
 
 The second signature of match is useful when the value being matched against
 is not already bound to an identifier (i.e. dot pipelines):
-```void
+```voyd
 fn main(a: i32, b: i32) -> String
   a.divide(b)
     .match(x) // Here, match binds the result of the previous expression to x

reference/functions.md

@@ -2,7 +2,7 @@
 
 ## Function Basics
 
-```void
+```voyd
 fn add(a: i32, b: i32) -> i32
   a + b
 
@@ -15,14 +15,14 @@ add(1, 2)
 
 With return type inference:
 
-```void
+```voyd
 // Equal sign is used when the function is written on one line
 fn add(a: i32, b: i32) = a + b
 ```
 
 With effects:
 
-```void
+```voyd
 fn get_json(address: String): Async -> Dictionary
   let json_text = await fetch(address)
   parse_json(json_text)
@@ -86,7 +86,7 @@ move(x: x, y: y, z: z)
 
 Labeled arguments also support concise closure sugar on call sites:
 
-```void
+```voyd
 fn try({ do: ((): throws -> void), catch: (e: Error) -> void })
 
 try do():
@@ -218,9 +218,9 @@ See the chapter on [Syntax](./syntax.md) for more information and detailed rules
 
 ## Function Overloading
 
-Void functions can be overloaded. Provided that function overload can be unambiguously distinguished via their parameters and return type.
+Voyd functions can be overloaded. Provided that function overload can be unambiguously distinguished via their parameters and return type.
 
-```void
+```voyd
 fn sum(a: i32, b: i32)
   print("Def 1")
   a + b
@@ -236,7 +236,7 @@ sum { a: 1, b: 2 } // Def 2
 This can be especially useful for overloading operators to support a custom
 type:
 
-```void
+```voyd
 fn '+'(a: Vec3, b: Vec3) -> Vec3
   Vec3(a.x + b.x, a.y + b.y, a.z + b.z)
 
@@ -247,15 +247,15 @@ A function call is considered to be ambiguous when multiple functions in
 the same scope share the same name, and the types of each parameter overlap
 in order.
 
-```void
+```voyd
 fn add(a: i32, b: i32) -> i32
 fn add(d: i32, e: i32) -> i32 // Ambiguous collision
 fn add(f: i32, c: f32) -> i32 // This is fine, the second parameter does not overlap with previous
 ```
 
 Object types overlap if one is an extension of the other:
 
-```void
+```voyd
 obj Animal {}
 obj Dog extends Animal {}
 obj Cat extends Animal {}