Added some comments on project.json. Methods mentioned to be useful for all types.

Author: lerno

src/content/docs/FAQ/index.mdx

@@ -379,6 +379,31 @@ int a = @test() {} + @test() {};
 
 C3 strives for a simple grammar, and so the trade-off of having to use `;` was a fairly low price to pay for this feature.
 
+## Choices in tooling
+
+**Q:** Why does C3 have comments in the default `project.json`?
+
+**A:** This was done as a way for users to understand what the various fields were used for. While this would more properly be
+a `.json5` file, many json parsers could ignore comments anyway. As tooling improves, comments will be phased out. Already it's
+possible to manipulate the project file from the command line.
+
+**Q:** Why does C3 use JSON for `project.json`, why not YAML, TOML or something else?
+
+**A:** JSON is a format with a parser in almost any language, plus it is straightforward to write a parser for.
+
+Originally C3 used TOML, which is great for manual configs. However, we moved away from this exactly because the project files
+should be easily generated and manipulated by tools, with no strict requirement that formatting remains the same.
+
+If tools manipulated hand-written TOML, there would be an expectation to retain formatting and comments in the same style, which
+would put a burden on tool writers.
+
+**Q:** Will C3 have a package manager?
+
+**A:** There will be some standard API for uploading and downloading C3 libraries. However, it will not be a full dependency manager.
+In an attempt to limit over-use of dependencies, each dependency will need to be downloaded separately, rather than automatically.
+
+See for example the discussion here: https://github.com/c3lang/c3c/issues/2077
+
 ## Cross-compiling To Windows From Linux
 **Q:** How do I cross-compile my C3 program for Windows on Linux?
 

src/content/docs/Language Fundamentals/functions.md

@@ -285,8 +285,8 @@ fn void print_input_with_chaining()
 
 ## Methods
 
-Methods look exactly like functions, but are prefixed with the type name and is (usually)
-invoked using dot syntax:
+Methods look exactly like functions, but are prefixed with a type name and is (usually)
+invoked using dot syntax, on an instance of the type.
 
 ```c3
 struct Point
@@ -331,6 +331,21 @@ fn bool State.may_open(State state)
 }
 ```
 
+You can add methods to all runtime types, including built-in types:
+
+```c3
+fn int int.add(int i, int other)
+{
+    return i + other;
+}
+
+fn void test()
+{
+    int i = 3;
+    int j = i.add(4);
+}
+```
+
 ### Implicit first parameters
 
 Because the type of the first argument is known, it may be left out. To indicate a pointer `&` is used.
@@ -349,7 +364,7 @@ It is customary to use `self` as the name of the first parameter, but it is not
 ### Restrictions on methods
 
 - Methods on a struct/union may not have the same name as a member.
-- Methods only work on `typedef`, `struct`, `union` and `enum` types.
+- Methods on enums may not have the same name as an associated value.
 - When taking a function pointer of a method, use the full name.
 - Using subtypes, overlapping function names will be shadowed.
 

src/content/docs/Language Overview/types.md

@@ -751,15 +751,14 @@ Const enums *cannot* have associated values and do not have the `nameof` propert
 ### Enum type properties
 
 Enum types have the following additional properties in addition to the usual properties for 
-user defined types:
+user-defined types:
 
 1. `associated` returns an untyped list of types for the associated values.
 2. `inner` returns the type of the ordinal as a `typeid`.
-3. `lookup(value)` lookup an enum by inlined value.
-4. `lookup_field(field_name, value)` lookup an enum by associated value.
-5. `names` returns a list containing the names of all enums.
-6. `from_ordinal(value)` convert an integer to an enum.
-7. `values` return a list containing all the enum values of an enum.
+3. `lookup_field(field_name, value)` lookup an enum by associated value.
+4. `names` returns a list containing the names of all enums.
+5. `from_ordinal(value)` convert an integer to an enum.
+6. `values` return a list containing all the enum values of an enum.
 
 ## Struct types
 
@@ -878,7 +877,7 @@ union Integral
 }
 ```
 
-As usual unions are used to hold one of many possible values:
+As usual, unions are used to hold one of many possible values:
 
 ```c3
 fn void test()
@@ -927,10 +926,10 @@ which returns a list of struct members.
 
 ## Bitstructs
 
-Bitstructs allows storing fields in a specific bit layout. A bitstruct may only contain
+Bitstructs allow storing fields in a specific bit layout. A bitstruct may only contain
 integer types and booleans, in most other respects it works like a struct.
 
-The main differences is that the bitstruct has a *backing type* and each field
+The main difference is that the bitstruct has a *backing type* and each field
 has a specific bit range. In addition, it's not possible *to take the address* of a
 bitstruct field.
 
@@ -983,8 +982,8 @@ fn void test()
 }
 ```
 
-It is however possible to pick a different endianness, in which case the entire representation
-will internally assume big endian layout:
+It is, however, possible to pick a different endianness, in which case the entire representation
+will internally assume big-endian layout:
 
 ```c3
 bitstruct Test : uint @bigendian