diff options
Diffstat (limited to 'v_windows/v/old/CHANGELOG.md')
| -rw-r--r-- | v_windows/v/old/CHANGELOG.md | 486 |
1 files changed, 486 insertions, 0 deletions
diff --git a/v_windows/v/old/CHANGELOG.md b/v_windows/v/old/CHANGELOG.md new file mode 100644 index 0000000..ae656f3 --- /dev/null +++ b/v_windows/v/old/CHANGELOG.md @@ -0,0 +1,486 @@ +-## V 0.2.4 +-*Not yet released, changelog is not full* +- 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. +- Bare metal support. Vinix OS kernel is now being developed in V. + +## V 0.2.2 - 0.2.3 +*22 Jan 2021* +- 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 + +## V 0.2.1 +*30 Dec 2020* +- 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. + +## V 0.2 +*22 Dec 2020* +- Compile-time memory management via `-autofree`. [Video demonstration](https://www.youtube.com/watch?v=gmB8ea8uLsM). +It will be enabled by default in 0.3 +- Channels and locks. +- Thread safe typed arrays via keyword `shared`. +- Struct embedding. +- IO streams. +- A powerful websocket module that conforms to RFC 6455 and passes the Autobahn test suite (498 client tests and 249 server tests). +- The `net` module is now non blocking and is more feature complete providing similar API to Go. +- V's graphics module now uses Metal/DirectX/OpenGL instead of just OpenGL. +- V can now run in the browser via WASM and execute V code by translating it to JavaScript: +https://v-wasm.now.sh +- V binaries for Linux/Windows/macOS are now built and deployed automatically via GitHub Actions. +- Smart casting for sumtypes and interfaces, including complex expressions: `if x.expr is int { println(x.expr + 1) }`. +- Clean and easy way to sort arrays: `users.sort(a.name > b.name)`. +- A huge amount of `vfmt` fixes and improvements. It has now reached a point where it can be safely used on any V source file. +- A new CI job that runs `v fmt -verify` on the entire code base, a new command that makes sure the file/directory +has been vfmt'ed. This ensures that all code submitted to the V project is formatted. +- A new tool `v vet` for analyzing the project and finding potential bugs and errors. +- A new `term.ui` module for building dynamic terminal UIs with an example editor written in it. +- Early iOS and Android support. +- All missing ORM features from the old backend were brought back. +- Magic `it` variable has been replaced with smart casts (the change is completely handled by vfmt). +- Cross-compiling to Windows and Linux brought back. +- C2V can now generate wrappers. Example: https://github.com/medvednikov/libsodium. (C2V will be released by 0.3) +- C++ compiler support: code, generated by the C backend can now by compiled by C++ compilers. +- Short generics syntax: `foo(5)` instead of `foo<int>(5)`. +- Cached modules via `-usecache`. Faster compilation due to not needing to rebuild the entire vlib for +each program. Will be enabled by default in 0.2.1. +- New improved sum types implementation. +- Lots of errors that happen often during the development cycle were turned into warnings to increase + development speed. They are still errors in production builds. +- Labeled `break` and `continue`. +- Lots of documentation. The official language documentation grew 3 times in size. +- `modules.vlang.io` is now generated automatically on every commit. +- Builtin compile-time JSON serializer now supports `time.Time`. +- Fixes in type aliases, to make them behave just like the types they alias. +- `array.contains(element)` is now generic. +- Lots of improvements in the JS backend and its type system. +- Simpler and more constinent function arg syntax: `foo(a int, b int, c string)` instead of `foo(a, b int, c string)` +- Lots of fixes and optimizations in the hashmap. +- Lots of missing checks in the type checker were added (for example, checking the correct usage of public struct fields). +- Mutability bug fixes +- Taking the address of a map value is no longer allowed, like in Go. +- Matrix multiplication. +- A new `#pkgconfig` flag to provide platform independent way to get compilation flags for C libraries/packages. +- Explicit parentheses requirement in complex boolean expressions. +- `println` was made even smarter, and can now handle complex types. +- Precompiled text templates can now be used outside of vweb via `$tmpl()`. +- Gitly, a big web application written in vweb has been released: https://github.com/vlang/gitly +- `['/:arg1/:arg2/action']` vweb action attribute for easily getting query parameters assigned to method arguments. +- Improved performance of text rendering, `gg.text_width()`. +- Webview module in V UI. +- Binary enum flags. +- `[export]` attribute to change exported function name (for example for calling from a C library). +- `unsafe` fixes and improvements. +- Improvements to rand: `rand.ulid()`, `rand.uuid()`, a unified customizable PRNG API. +- Hundreds of other fixes, features, and tests (from now on the changelog will be updated +right away as the feature/bug fix lands). + + +## V 0.1.27 +*5 May 2020* + +- vfmt has been re-written from scratch using the new AST parser. + It's much faster, cleaner, and can format +files with compilation errors. +- `strconv`, `sprintf`, and `printf` in native V, without any libc calls. +- Interfaces are now a lot more stable and have all expected features. +- Lots of x64 backend improvements: function calls, if expressions, for loops, local variables. +- `map()` and `filter()` methods can now be chained. +- New `[]int{cap:cap, len:len}` syntax for initializing array length and capacity. +- New `is` keyword for checking the type of sum types and interfaces. +- `as` can now be used to cast interfaces and sum types. +- Profiling with `-profile`. Prints a nice table with details about every single function call: + number of calls, average time per call, total time per function +- `import(xxx)` syntax has been removed in favor of `import xxx` for simplicity and greppability. +- Lots of fixes and improvements in the type checker. +- `time.StopWatch` +- `dl` module for dynamic loading. +- Automatic `str()` method generation for every single type, including all arrays. +- Short struct initialization syntax for imitating named function args: `foo(bar:0, baz:1)`. +- New operator `!in`. +- Performance improvements in critical parts of the builtin data structures (array, map). +- High order functions improvements (functions can now be returned etc). +- Anonymous functions that can be defined inside other functions. +- Built-in JSON module is back. +- Lots and lots of new tests added, including output tests that test error messages. +- Multiple errors are now printed, the compiler no longer stops after the first error. +- The new JS backend using the AST parser (almost complete). +- Variadic functions. +- `net.websocket` module (early stage). +- `vlib` is now memory leak free, lots of `autofree` improvements. +- Simplified and cleaned up `cmd/v`, `v.builder`. +- V UI was updated to work with the new backend. + + +## V 0.1.25 +*1 Apr 2020* + +- The entire compiler has been re-written with an AST parser. + The code is now a lot cleaner and more maintainable. + ~15k lines of old compiler code were removed. + +## V 0.1.24 +*31 Dec 2019* + +- A new parser/generator built on top of an AST that simplifies code greatly + and allows to implement new backends much faster. +- Sum types (`type Expr = IfExpr | MatchExpr | IntegerLiteral`). +- B-tree map (sped up the V compiler by ~10%). +- `v fmt -w`. +- The entire code base has been formatted with vfmt. +- Generic structs. +- SDL module. +- Arrays of pointers. +- os: `is_link()`, `is_dir()`, `exists()`. +- Ranging through fixed size arrays. +- Lots of fixes in ORM and vweb. +- The first tutorial: [building a simple web application with vweb](https://github.com/vlang/v/blob/master/tutorials/building_a_simple_web_blog_with_vweb/README.md) +- Match expressions now must be exhaustive. +- freestanding: `malloc()`/`free()`. +- `++` is now required instead of `+= 1` for consistency. +- Interpolated strings now allow function calls: `println('val = $get_val()')`. +- `string.replace_each([])` for an efficient replacement of multiple values. +- More utf8 helper functions. +- `-prealloc` option for block allocations. +- `type` aliases. +- Running `v` with an unknown command will result in an error. +- `atof` implementation in pure V. +- Enums can now have negative values. +- New `filepath` module. +- `math.factorial`. +- `ftp` module. +- New syntax for casting: `val as Type`. +- Fewer libc functions used (soon V will have no dependency on libc). + + +## V 0.1.23 +*30 Nov 2019* + +- [Direct x64 machine code generation](https://github.com/vlang/v/issues/2849). + Hello world being built in 3 milliseconds. +- Bare metal support via the `-freestanding` flag, to build programs without linking to libc. +- Prebuilt V packages for Linux, macOS, and Windows. +- `string.index()` now returns `?int` instead of `int/-1`. +- Lots of fixes in Generics. +- vweb framework for developing web applications is back. +- Vorum, the forum/blogging software written in vweb, can now be compiled and has been added to CI. +- REPL, `v up` have been split up into separate applications to keep the core V compiler small. +- V now enforces short enum syntax (`.green` instead of `Color.green`) when it's enough. +- V UI for macOS. +- Interfaces have been rewritten. `[]interface` support. +- `os.cp()` for copying files and directores. +- Additional compile-time flags: `$if clang, msvc, mingw, x32, x64, big_endian, little_endian {`. +- All C functions now have to be declared, all missing C functions have been defined. +- Global variables (only with the `-enable-globals` flag) + for low level applications like kernels and drivers. +- Nothing can be cast to bool (previously code like `if bool(1) {` worked). +- `<<` and `>>` now work with all integer types. +- V detects Cygwin and shows an error (V supports Windows natively). +- Improved type checking of some operators (`%, |, &` etc). +- Windows 7 support. +- `println(true)` now prints `true` instead of `1`. +- `os.exec()` now uses `CreateProcess` on Windows. +- fast.vlang.io website for monitoring the performance of V after every commit. +- On Windows Visual Studio is now used automatically if GCC is not installed. +- vfmt! +- Lots of cleaning up in the compiler code. +- Multi-level pointers in unsafe code (`****int`). +- MSVC backtrace. +- `$if os {` blocks are now skipped on a different OS. +- C string literals (`c'hello'`). +- AlpineLinux/musl fixes + added to CI. +- Inline assembly. +- Clipboard module (Windows, macOS, X). +- `foo()?` syntax for error propagation. +- Docs have been migrated from HTML to `doc/docs.md`. +- `eventbus` module. +- Haiku OS support. +- `malloc/free` on bare metal. +- `utf8` helper functions (`to_lower()`, `to_upper()`, etc). +- Optimization of `for c in str {`. +- `string/array.left/right/slice/substr` were removed (use `[a..b]` slicing syntax instead). + + + +## V 0.1.22 +*28 Oct 2019* + +- Generic functions (`fn foo<T>(bar T) T {`) with varargs support. +- `array[start..end]` and `string[start..end]` slicing syntax. +- Optimized `array.filter()` and `array.map()`. +- `sqlite` module. +- Cached modules for faster compilation. +- Dramatic compilation optimizations: [V now compiles itself in 0.10 - 0.30 seconds](https://github.com/vlang/v/wiki/The-V-language-now-compiles-itself-in-0.09-seconds) +- V scripts (simpler and cross-platform alternative to Bash). +- Infinite multi-dimensional arrays (`[][][]int`). +- `unsafe`. +- `[deprecated]` attribute. +- `[if]` function attributes for compile time function exclusion for performance. +- `switch` has been completely removed from the language and replaced by +`match` everywhere. +- `pub struct` and `pub const`, previously all structs and consts were public +by default. +- `musl` support (V can now run on, for example, Alpine Linux). +- Module header generation. V now supports closed source modules, which are still +used in some industries. +- Constants were added to typo suggestions. +- `color in [.green, .red, .blue]` now works without specifying `Color.green`. +- V compiler is now a module that can be used by other programs. +- Backtraces now have source lines on Linux. +- `runtime.nr_cpus()`. +- `fn init()` for module initialization. +- `a in [1, 2, 3]` optimization: no array gets allocated. +- Raw strings: `s := r'hello\nworld'`. +- `if a := func() { }` syntax for handling optionals. +- f32/f64 comparison now uses machine epsilon by default. + + +## V 0.1.21 +*30 Sep 2019* + +- `none` keyword for optionals. +- Solaris support. +- All table lookup functions now use `none`. +- varargs: `fn foo(bar int, params ...string) {`. +- Double quotes (`"`) can now also be used to denote strings. +- GitHub Actions CI in addition to Travis. +- `-compress` option. The V binary built with `-compress` is only ~90 KB! +- More memory management. +- Unused modules result in an error. +- "Unused variable/module" errors are now warnings in non-production builds. +- Duplicate methods with the same name can no longer be defined. +- Struct names must be capitalized, variable/function names must use snake_case. +- Error messages are now even nicer! +- Lots of fixes in automatic `.str()` method generation for structs and arrays. +- ~30% faster parser (files are no longer parsed separately for each pass). +- `_` is no longer a variable, but an actual syntax construct to skip unused values, like in Go. +- Multiple returns (`fn foo() (int, string) {`). +- `!` can now only be used with booleans. + + +## V 0.1.20 +*17 Sep 2019* + +- JavaScript backend! +- Hundreds of C warnings were fixed. `gcc v.c` now builds without +any warnings. +- The mutability check now applies to function args (mutable +receivers that are not modified result in a compilation error). +- V tests now show how long each test took. +- Official Android support (only console applications via Termux for now). +- Typo check. If a variable/function/module etc is misspelled, +V will suggest the correct name. +- Lots of Microsoft C fixes, and a separate Travis instance for +this backend. +- Bitwise operators `|`, `^`, `&` no longer work with booleans. + + +## V 0.1.19 +*12 Sep 2019* + +- Lots of refactoring, simplifications, and optimizations in the compiler. +- Experimental memory management at compilation (only for the V compiler itself for now). +- Lots of ORM fixes. +- Functions can now be inlined via the `[inline]` attribute. +- New `mysql` module. +- Better error format that is supported by all major editors (go to error). +- Error messages now point to the actual place where the error happened. +- Custom json field names: `struct User { last_name string [json:lastName] }`. +- Raw json fields via the `[raw]` attribute. +- All C code was removed from the `freetype` module. +- `gg` module can now render all Unicode characters. +- `[typedef]` attribute for imported C struct typedefs. +- Support of Objective C interfaces (primarily for using Cocoa). +- REPL: clear command and custom functions. +- REPL tests (which are also used for testing certain compiler errors). +- Syntax bug fixed: `foo[0] += 10` is now possible. +- http: support plain HTTP protocol and follow redirects. +- http: header data is now processed correctly. +- net: basic UDP support. +- `import const` was removed from the language. +- `array.contains()` was removed from the language (`in` should be used instead). +- `[0; len]` syntax was removed (replaced with a simpler `[0].repeat(len)`) +- Primitive aliases were removed to simplify the language. +- GitHub supports V now! +- Backtraces are now printed on panics. +- A new awesome `readline` module. +- V.c is now regenerated automatically after every commit. +- A bug with struct ordering was fixed, now structs can be declared in any order. +- V modules can now be built with `v build module`. +- `@FILE, @LINE, @FN, @COLUMN` for debugging. + + +## V 0.1.18 +*16 Aug 2019* + +- Built-in ORM (`uk_customers = db.select from Customer where country == 'uk' && nr_orders > 0`). +- Map initialization syntax: `m := { ‘foo’: ‘bar’, ‘baz’: ‘foo’ }`. +- `map.delete(key)`. +- `libcurl` dependency was removed from the `http` module. +- All function arguments are now immutable by default (previously they could be + modifed inside the function). +- `http` functions now return optionals. +- `sync.WaitGroup`. +- `vweb` static files serving. +- `crypto.rand` module. +- `v up` to update V. +- SChannel support on Windows. +- `net.urllib` module. +- vpm package manager, `v install`. +- `()` are now required in complex bool expressions: `(a && b) || c` instead of `a && b || c`. +- All arrays now have a default `.str()` method. +- Bootstrapping V with MSVC. +- Experimental `≠` etc support. +- `encoding.csv` module. +- `$if debug {` for running code in debug mode only. +- Map struct fields are now initialized automatically, just like arrays. +- Maps now support array values. +- `json` functions can no longer be used if the `json` module is not imported. + + +## V 0.1.17 +*29 Jul 2019* +- `vweb` module for developing web apps in V. +- vtalk, open source V forum software. +- Generics (very limited right now, but they will be gradually improved). +- Comptime codegen (`foo.$method()` where `method` is a string). +- @ for escaping keywords (e.g. `struct Foo { @type string }`). +- Windows Unicode fixes (V can now work with non-ASCII paths etc on Windows). +- Fix mutable args bugs + don't allow primitive arguments to be modified. +- Declaring a mutable variable and never modifying it results in a compilation error. +- Interactive debugging support. +- `sync` module for Windows. +- `#!` support on Unix systems (V scripts). +- Lots of Visual Studio fixes. +- `crypto.aes` and `crypto.rc4` modules. +- Internal modules. + + +## V 0.1.16 +*23 Jul 2019* +- V can now be used with Visual Studio! +- Hot code reloading now works with graphical applications (e.g. graph.v, bounce.v). +- Compile time memory management for arrays. +- High order functions. +- `match` expression (replacing `switch`). +- Import cycle detection. +- `crypto/md5`, `crypto/sha256`, and `crypro/sha512` modules. +- `os.executable()` - a cross platform function that returns full path to current executable. +- `~/.vlang` and `VROOT` were removed entirely. The installation is a lot cleaner now. +- V can now be packaged for all Linux distros. +- Arch Linux package. +- `string(bytes_buffer, len)`, `string(bytes_array)` casts. +- Multiple `defer`s. +- `key in map` syntax (replacing `map.exists(key)`). + + +## V 0.1.15 +*15 Jul 2019* +- FreeBSD, OpenBSD, NetBSD, DragonFly support. +- Hot reloading now works with graphical applications: [bounce.v](examples/hot_reload/bounce.v) +- VROOT was removed, the installation process is now much simpler. +- `defer` statement. +- map.v was re-written. It's now much faster. +- `for key, val in map` syntax. +- `flag` module for parsing command line arguments. +- `zip` module. +- `crypto/sha1` module. +- Submodules and module aliases (`import encoding.base64 as b64`). + + +## V 0.1.14 +*12 Jul 2019* +- `gg` module Windows support, V Tetris runs on Windows. +- Compile `glad` and `cJSON` only once. Programs using `gg` or `json` compile a bit faster. +- `v.c` has been cleaned up and minimized (~16k => ~10k lines of code). +- `type` aliases can now have methods. +- Const overflow check during compilation (`byte(1000)` will no longer compile). + + +## V 0.1.13 +*10 Jul 2019* +- New enum syntax (`token == .name`), enum values are no longer global consts. +- Submodules (`import encoding.base64`). +- Hot code reloading. +- Special `err` variable for getting error values. +- Complex numbers. +- `<<` can now append arrays (`numbers << [1, 2, 3]`). +- Lots of Windows fixes (Windows still needs some work). +- Lots of REPL improvements (e.g. `>> 2 + 3` works now, no `println` required). +- The website was made easily translatable, it's now partially available in several languages. + + +## V 0.1.12 +*4 Jul 2019* +- V can finally compile itself on Windows (https://github.com/vlang/v#mingw-w64). +- `os` module now uses optionals in all functions that return `File`. +- Lots of bugs with optionals were fixed. +- `println` was optimized. It no longer results in allocations. + Now it also works correctly with all integer types. +- Lots of `vfmt` fixes, it will be enabled tomorrow. +- New `strings` module. +- Lots of other fixes and improvements, thanks to all the contributors. + + +## V 0.1.11 +*1 Jul 2019* +- Cross compilation for Windows! +- Lots of Windows fixes. +- socket.v. +- maps fixed. + + +## V 0.1.9 - 0.1.10 +*29 Jun 2019* +- Windows support via MinGW-w64. Pre-built Windows binary. +- File structure has been simplified: all vlib modules were moved to the vlib/ directory, + makefile was moved to the root. +- One single archive with pre-built binaries for all operating systems. +- `mut var := val` was fixed (previously `mut var = val` was allowed as well). + + +## V 0.1.8 +*28 Jun 2019* +- Single file programs without `fn main` now work as expected. +- REPL has been fixed: it now supports imports, consts, function definitions, etc. + + +## V 0.1.7 +*27 Jun 2019* +- All C code in the compiler and vlib has been replaced with V. +- `#` syntax for embedding C code has been removed. +- Exported functions now need to be marked with `pub`, all public vlib functions have been updated. +- CI has been set up (Travis + Azure). On every commit and PR it is made sure that V + can compile itself, all tests pass, and all examples compile. +- More tests have been uploaded. +- Cleaner bytes to string conversion: `tos2(bytes)` => `string(bytes)`. +- The home page has 3 more examples next to 'hello world' that show the features of the language. +- Lots of bugs and issues fixed. |