Update README

README.md

@@ -63,19 +63,67 @@ Release :: (m: *Memory)
 
 ```
 
+## What's missing ?
 
-## Features
+- [x] Constant evaluation and constant folding - Folding and precomputing every expression that can be calculated at compile time. Which allows to check if a given constant expression is actually something that can be computed at compile time.
+  - [ ] Constant expressions with types specified by the user.
 
-* Order independent declarations
+- [x] Untyped types - Context dependent type assignment of constant expressions, this is a feature I really loved in Go, it makes constants work very well with a very strict type system and it makes errors like overflow of constants in C due to bad size specifier impossible.
-* Module system
+  - [x] Infinite precision integers in constants.
-  * #import for lazy loading(unused code is not compiled, big win)
+  - [x] Resolution of all untyped types in the typechecking stage.
-  * #load for normal loading
+  - [x] Special case of booleans and their type propagation.
-* Types as first class values and runtime reflection
+
-  * Any type
+- [x] Module system
-  * Type type
+  - [x] Lazy evaluation of modules (unused code is not compiled or typechecked)
-* Slices
+  - [x] Import module, load project file distinction
-* Whitespace significant syntax
+
-* Debuggable(emitting proper line directives)
+- [x] Order independent declarations - The ordering of functions in code files or modules does not matter, compiler figures all that stuff out for you. "main" can be wherever you want it to be and all functions should be available without problems.
+
+- [x] Synchronize generated C code with original source using line directives so that debuggers work.
+
+- [ ] Expressions
+  - [x] Compounds with named fields and numbered fields
+  - [x] Functions calls with named arguments
+  - [x] All the standard binary, unary expressions
+  - [x] Pointer arithmetic and pointer as array
+  - [ ] Dot access expression needs a redesign
+  - [ ] Casting might need a redesign not sure
+
+- [x] Runtime reflection
+  - [x] Dumping info
+  - [ ] Is the design of this correct? That's a lot of data.
+
+- [ ] Builtin data structures
+  - [x] Arrays
+  - [x] Slices
+  - [ ] Dynamic arrays
+  - [ ] Hash tables
+  - [ ] Tuples
+    - [x] Multiple return values from a function
+    - [ ] Some kind of tuple expressions
+    - [ ] Using tuples as single values without unpacking
+
+
+- [ ] Generics / Parametric polymorphism
+
+- [ ] Function overloading
+
+- [ ] Operator overloading
+
+- [ ] Platforms
+  - [x] Windows
+  - [ ] Unix based
+
+- [ ] Language constructs
+  - [x] If
+  - [x] For loops
+  - [x] Functions
+  - [x] Structures
+  - [x] Switch (but maybe needs redesign?)
+  - [ ] Jai like using statement
+  - [ ] Defer statement
+  - [ ] Unions (or something like unions)
+  - [ ] Unnamed blocks
 
 ## Building
 
@@ -93,60 +141,3 @@ Stuff that helped me a lot programming the compiler. Hopefully they also will be
 * https://github.com/JoshuaManton/sif - looked at this as a reference from time to time, author seems like a Jonathan Blow fan so it was a good resource informed by similar resources as I used.
 * https://github.com/c3lang/c3c - I sometimes looked at C3 compiler as a reference, the author also let me use his big int library he wrote sometime in the past! Thanks a lot!
 * https://go.dev/blog/constants - article on golang type system, untyped types, constants that kind of stuff.
-
-## Done
-
-- [x] Constant evaluation and constant folding - Folding and precomputing every expression that can be calculated at compile time. Which allows to check if a given constant expression is actually something that can be computed at compile time.
-  - [ ] Constant expressions with types specified by the user.
-
-- [x] Untyped types - Context dependent type assignment of constant expressions, this is a feature I really loved in Go, it makes constants work very well with a very strict type system and it makes errors like overflow of constants in C due to bad size specifier impossible.
-  - [x] Infinite precision integers in constants.
-  - [x] Resolution of all untyped types in the typechecking stage.
-  - [x] Special case of booleans and their type propagation.
-
-- [x] Module system
-  - [x] Lazy evaluation of modules (unused code is not compiled or typechecked)
-  - [x] Import module, load project file distinction
-
-- [x] Order independent declarations - The ordering of functions in code files or modules does not matter, compiler figures all that stuff out for you. "main" can be wherever you want it to be and all functions should be available without problems.
-  - [ ] Should constants and others be disallowed inside of structs?
-
-- [x] Synchronize generated C code with original source using line directives so that debuggers work.
-
-- [ ] Expressions
-  - [x] Compounds with named fields and numbered fields
-  - [x] Functions calls with named arguments
-  - [x] All the standard binary, unary expressions
-  - [ ] Dot access expression needs a redesign
-  - [ ] Casting might need a redesign not sure
-  - [x] Pointer arithmetic and pointer as array
-
-- [ ] Tuples
-  - [x] Multiple return values from a function
-  - [ ] Some kind of tuple expressions
-  - [ ] Using tuples as single values without unpacking
-
-- [x] Runtime reflection
-  - [x] Dumping info
-  - [ ] Is the design of this correct? That's a lot of data.
-
-- [ ] Builtin data structures
-  - [x] Arrays
-  - [x] Slices
-  - [ ] Dynamic arrays
-  - [ ] Hash tables
-
-- [ ] Generics / Parametric polymorphism
-
-- [ ] Platforms
-  - [x] Windows
-  - [ ] Unix based
-
-- [ ] Language constructs
-  - [x] If
-  - [x] For loops
-  - [x] Functions
-  - [x] Structures
-  - [ ] Unions (or something like unions)
-  - [x] Switch (but maybe needs redesign?)
-  - [ ] Unnamed blocks