Update README

README.md

@@ -73,14 +73,15 @@ Dot    :: (a: Vec3, b: Vec3): F32  ;; return a.x*b.x + a.y*b.y + a.z*b.z
 
 ## What's missing ?
 
-- [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
-
+- [x] Typechecking - very strict typesystem, inspired by Go, no implicit conversions outside of special types like void or Any.
+  - [x] Constant evaluation and constant folding - Folding and precomputing every expression that can be calculated at compile time.
   - [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 using big ints! No more overflows or underflows (at least at compile time).
 
 - [x] Module system
   - [x] Lazy evaluation of modules (unused code is not compiled or typechecked)
   - [x] Import module, load project file distinction
+  - [x] Linking to libraries through importing a module, module calls ```#link``` and that is added to linked libraries.
 
 - [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
 
@@ -93,25 +94,30 @@ Dot    :: (a: Vec3, b: Vec3): F32  ;; return a.x*b.x + a.y*b.y + a.z*b.z
   - [x] All the standard binary, unary expressions
   - [x] Pointer arithmetic and pointer as array
   - [x] Dot access expression needs a redesign because it doesn't handle expressions after the dot, requires identifiers
-  - [ ] Casting might need a redesign not sure from '->' to 'cast'
+  - [ ] Casting might need a redesign not sure. From '->' to 'cast', and maybe more options like Odin ```transmute```.
 
 - [x] Runtime reflection
   - [x] Package of type and pointer which enables dynamic typing
   - [x] Types are values holding type ids, this way we can do if TypeOf(value) == S64 ;; blah
   - [x] Typesafe variadic arguments using []Any slice (no more var args!)
   - [x] Any semantics that make it easy to use (automatic unpacking to pointer and type)
-  - [x] Optional type information dump
+  - [x] Optional type information dump which allows an application to recursively serialize the data. Something you would need special tools for in C++.
   - [ ] Is the design of this correct? That's a lot of data.
 
 - [ ] Builtin data structures
   - [x] Arrays
   - [x] Slices
-  - [ ] Dynamic arrays
-  - [ ] Hash tables
+  - [ ] Dynamic arrays. (Do we want this?)
+  - [ ] Hash tables. (Do we want this?)
 
 - [x] Multiple return values
 
-- [ ] Generics / Parametric polymorphism
+- [ ] Polymorphism
+  - [x] C like void type
+  - [x] Any with it's dynamic typing
+  - [ ] Generics aka compile time polymorphism aka parametric polymorphism
+  - [ ] Something akin to inheritence
+  - [ ] Something akin to C unions or Rust's enums
 
 - [x] Operator overloading
   - [x] Binary operators

core_main.cpp

@@ -2,8 +2,7 @@
 
 Current:
 
-- [ ] Foreign import that would link library
-- [ ] String in Language.core
+- [ ] String declaration in Language.core
 - [ ] Way to import and force evaluate #import_lazy #import ?
 
 - [ ] Imports are leaking names ! Multimedia leaks windows stuff

modules/GDI32.core

@@ -33,7 +33,6 @@ BLACKNESS :: 0x00000042 /* dest = BLACK                    */
 WHITENESS :: 0x00FF0062 /* dest = WHITE                    */
 
 
-// #import #foreign "gdi32.lib" @todo
 CreateDIBSection   :: #foreign (hdc: HDC, pbmi: *BITMAPINFO, usage: UINT, ppvBits: **VOID, hSection: HANDLE, offset: DWORD): HBITMAP
 CreateCompatibleDC :: #foreign (hdc: HDC): HDC
 SelectObject       :: #foreign (hdc: HDC, h: HGDIOBJ): HGDIOBJ

modules/Math.core

@@ -1,3 +1,4 @@
+
 sqrtf :: #foreign (value: F32): F32
 cosf  :: #foreign (value: F32): F32
 sinf  :: #foreign (value: F32): F32