1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/CHANGELOG.md
2021-01-24 10:54:27 +01:00

22 KiB
Raw Blame History

-## V 0.2.4 -Not yet released

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 allows shadowing consts safely and makes it easy to distinguish them from local variables.

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. 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.
  • Closures.
  • 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
  • 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. 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
  • 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 defers.
  • 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
  • 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.