V 0.3 is out!

5769 commits pushed to master, 1697 bugs closed since V 0.2.

It's been a while since the last major release, from now on we'll do major releases every ≈4 months.

• C to V translation via C2V: v translate file.c. (Demo video: Translating DOOM from C to V, building it in under a second and running it!)
• Lots of bug fixes in V, cgen, and C interop to allow running translated DOOM.v.
• Programs built with the V compiler no longer leak memory by default.
• Closures. All operating systems are supported. (Demo)
• Option and Result are now separate types: ?Foo and !Foo respectively. Old code will continue working for 1 year and will result in a warning/hint.
• Hundreds of new checks in the type checker.
• All V's backends have been split up into separate processes. As the result, building V got 26% faster.
• Maps and arrays can now return optionals: m[bad_key] or { ... }, if x := arr[key] { ... }.
• ustring has been replaced with []rune (works just like in Go).
• Maps can now have non-string keys.
• A new compiler pass for transforming the AST (doesn't slow the compiler too much, adds about 25ms to v self). It eliminates unreachable branches and performs other simple optimizations and transformations.
• C backend is now parallel (just the cgen part for now).
• Lots of compiler source code clean up and minor optimizations. The compiler got ~30% faster according to fast.vlang.io.
• Better compiler source code organization (absolutely necessary as it's surpassed 100k loc).
• The naming of V's integer types is now more consistent: byte has been renamed to u8. Old code will continue working for 1 year and will result in a warning/hint.
• The typo detector now highlights the suggested name so that it's more visible.
• datatypes module now has Heap, Queue, Stack, BSTree, LinkedList.
• Interfaces can now be embedded (like structs).
• vlib now has a TOML parser, fully compatible with TOML 1.0.
• Lots of work done on the V.js backend, including the graphics library, which has been ported to V.js.
• JS promises, await (V.js).
• It's now possible to do more complex array initialization by using each individual element of the array ([]int{init: it}).
• Unsigned right shift operators >>> and >>>= have been added to V. (They work exactly like in Java.)
• -nofloat option, which is useful for writing kernels and for embedded systems without an FPU (used in Vinix).
• Generic interfaces.
• TCC is now bundled with the language, this allows building V programs without an external C compiler dependency.
• Null can be used in unsafe only (for example, for C interop).
• Pointer arithmetics and comparing pointers to numbers is now also only allowed in unsafe.
• Inline sumtypes.
• New module compress.gzip.
• Lots of net/net.http/vweb fixes (also used for the upcoming Gitly launch).
• IPv6 support.
• net.http headers are now enum fields instead of strings. This allows to avoid typos and offers autocomplete.
• Struct field deprecation.
• Static GC (no longer a dynamic lib dependency).
• New various algorithms for random number generation: MT19937RNG, etc (module rand).
• Fix immutability bugs that allowed to bypass compiler immutability checks and modify const/immutable values.
• Lots of fixes in the JSON serializer.
• Heap allocated only structs marked with [heap].
• Significantly improve lots of error messages, make them more clear, suggest hints.
• Bug fixes and new features in the pure V regex module.
• Lots of new drawing functions in the graphics module (like gg.draw_polygon_filled(), gg.draw_arc_empty() etc)
• Builtin FPS display in gg.
• Latest Sokol backend in gg.
• Advanced CI tests for the graphics module. Graphical apps are run on GitHub Actions instances, their output is saved to an image, uploaded, and compared to the expected result.
• More bug fixes in generics.
• Bug fixes in aliases. They can now fully replace the types they alias.
• `[minify] struct attribute for struct minification.
• for in now works with fixed arrays.
• The parser was made a bit faster by skipping vfmt code when not in vfmt mode (by using -d vfmt).
• Lots of vfmt improvements, especially with comments.
• Experimental #[index] syntax for negative indexing (like in Python, but needs special syntax instead of being used by default).
• Visibility bug fixes in modules (pub).
• Error propagation in complex expressions (e.g. foo(bar()?)).
• Optionals can now by used in consts (const x := opt() or {}).
• Lots of new documentation, including vlib modules documentation and the official V Documentation.
• vpm improvements (including a new vpm mirror).
• sync improvements including sync.thread_id(), sync.Once..
• V can now be used to generate object files (foo.o) that can be used in existing C projects.
• -usecache and -skip-unused fixes, they are close to being on by default.
• Lots of Windows issues fixed.
• Amazon Linux support.
• Fixes in shared maps and arrays.
• term.ui improvements, including multi byte/UTF-8 events.
• New crypto modules, including crypto.des, crypto.cipher, crypto.blowfish.
• Comptime fixes.
• 4 byte bool option (-d 4bytebool) for compatibility with some C software.
• strconv (pure V formatting module used in string interpolation) fixes and performance improvements.
• ORM fixes (pg, mysql, sqlite). Tables are now created automatically based on the V structs, no more need in sql files to create tables for apps.
• volatile keyword.
• "stringliteral".len optimization (replaced by the actual number by the new transform pass).
• Lots of inline assembler improvements (it's used a lot in Vinix).
• Many new functions in the math module.
• Separators in number literals: 1_000_000.
• strings.Builder optimizations and new methods.
• Autofree fixes (still not production ready, hidden behind the -autofree flag).
• Lots of Android fixes in V and in vab.
• Lots of commits to the native backend (amd64/arm64).
• V interpreter fixes. (Still at an early stage.)
• Go2V translator has been started by the community, and can already translate simple programs.
• An early version of the Go backend (v -b go -o file.go file.v).
• Introduce isize and usize types, deprecate size_t in favor of usize.
• Add datatypes and datatypes.fsm modules.
• Add compile_error and compile_warn comptime functions.
• Bare metal support. Vinix OS kernel is now being developed in V.
• Builtin web framework vweb is now multithreaded, all CPU cores are used.
• String interpolation and struct stringers are now implemented in pure V
  with a much cleaner and faster implementation. Previously libc's sprintf
  was used.
• Improved unused variable warning. Assigning to a variable no longer marks it as used.
• Allow interfaces to define fields, not just methods.
• vweb now uses struct embedding: app.vweb.text('hello') => app.text('hello').
• Consts can now be declared outside of const() blocks: const x = 0.
• Overloading of >, <, !=, ==, <= and >= operators.
• New struct updating syntax: User{ ...u, name: 'new' } to replace { u | name: 'new' }.
• byte.str() has been fixed and works like all other numbers. byte.ascii_str() has been added.
• Smart cast in for loops: for mut x is string {}.
• [noinit] struct attribute to disallow direct struct initialization with Foo{}.
• Array decompose: [1, 2, 3]... is now ...[1, 2, 3]
• Treating enum as int and operations on enum except == and != are removed for strict type checking.
• Support [manualfree] fn f1(){} and [manualfree] module m1, for functions doing their own memory management.
• Allow usage of < and > operators for struct in .sort method for arrays, i.e. arr.sort(a < b).
• Auto generate assignment operators like +=, -=, *=, /= and %= if the operators are defined.
• Colorize and improve failing tests output.
• Fix go with a generic function: go test<string>(c, 'abcd').
• Add comptime x := $embed_file('v.png') println(x.len) println(ptr_str(x.data())), for embedding files into binaries.
• Advanced vdoc search on mobile layout.
• string's left()/right were removed in favor of slicing syntax: str[..pos].
• gg: native graphics mode on macOS/iOS (using Cocoa Drawing API).
• Full path to consts must be specified everywhere. This makes it easy to distinguish them
  from local variables.
• __offsetof for low level needs (works like offsetof in C).
• vfmt now preserves empty lines, like gofmt.
• Support for compile time environment variables via $env('ENV_VAR').
• Allow method declaration of == and < operators and auto generate !=, >, <= and >=.
• support dump(expr), i.e. tracing of both the location, name and value of an expression
• deprecate os.exec in favour of os.executable() which does NOT return an option, when the command was not found
• Hashmap bootstrapping fixes.
• Array decomposition to varargs: fn sum(i ...int) int => a := [2,3,4] println(sum(a...))
• HTML module docs generated by vdoc now have global search.