It’s time for the release of Vala 0.7.6. Tarballs are available from the GNOME FTP servers. This release includes a couple of new features worth explaining in a bit more detail.

Closures

While Vala has lambda expressions for a long time, they haven’t supported accessing local variables from the outer method. With the release of Vala 0.7.6 this has changed, and you can access and set any local variable from lambda expressions. One place where I’d expect this to be convenient is in signal handlers:

void main ( string [ ] args ) { Gtk . init ( ref args ) ; var window = new Gtk . Window ( Gtk . WindowType . TOPLEVEL ) ; window . set_default_size ( 300 , 50 ) ; window . destroy . connect ( Gtk . main_quit ) ; var button = new Gtk . Button . with_label ( "Click me!" ) ; button . clicked . connect ( ( ) => { window . title = "Closures in Vala" ; } ) ; window . add ( button ) ; window . show_all ( ) ; Gtk . main ( ) ; } void main (string[] args) { Gtk.init (ref args); var window = new Gtk.Window (Gtk.WindowType.TOPLEVEL); window.set_default_size (300, 50); window.destroy.connect (Gtk.main_quit); var button = new Gtk.Button.with_label ("Click me!"); button.clicked.connect (() => { window.title = "Closures in Vala"; }); window.add (button); window.show_all (); Gtk.main (); }

You can even write recursive lambda expressions:

delegate int Func ( int i ) ; void main ( ) { Func fib = null ; fib = ( i ) => ( i <= 1 ) ? i : ( fib ( i - 2 ) + fib ( i - 1 ) ) ; for ( int i = 0 ; i < 10 ; i ++ ) { message ( "%d" , fib ( i ) ) ; } } delegate int Func (int i); void main () { Func fib = null; fib = (i) => (i <= 1) ? i : (fib (i - 2) + fib (i - 1)); for (int i = 0; i < 10; i++) { message ("%d", fib (i)); } }

Asynchronous methods

The idea of integrating async methods into the language is to make it easier to write code that calls or implements async methods. Async methods are frequently used in I/O API such as GIO and in D-Bus clients and servers. Traditionally, writing async code has beeen quite painful as you often end up writing callback chains and completely lose track over the control flow in the process.

Experimental support for async methods has been implemented in Vala almost a year ago. However, the implementation was rather a proof of concept than a finished solution. While I still expect a few bugs in that area with 0.7.6, it’s a lot more robust and complete than it used to be a short time ago.

So how does it look like? It’s not unlike Alex’s AsyncRunner in JavaScript except that it’s even more concise as it’s fully integrated into the language. The following code defines an async method list_dir that asynchronously enumerates all files in the home directory:

async void list_dir ( ) { var dir = File . new_for_path ( Environment . get_home_dir ( ) ) ; try { var e = yield dir . enumerate_children_async ( FILE_ATTRIBUTE_STANDARD_NAME, 0 , Priority . DEFAULT , null ) ; while ( true ) { var files = yield e . next_files_async ( 10 , Priority . DEFAULT , null ) ; if ( files == null ) { break ; } foreach ( var info in files ) { print ( "%s

" , info . get_name ( ) ) ; } } } catch ( GLib . Error err ) { warning ( "Error: %s

" , err . message ) ; } } void main ( ) { list_dir . begin ( ) ; var loop = new GLib . MainLoop ( null , false ) ; loop . run ( ) ; } async void list_dir () { var dir = File.new_for_path (Environment.get_home_dir ()); try { var e = yield dir.enumerate_children_async (FILE_ATTRIBUTE_STANDARD_NAME, 0, Priority.DEFAULT, null); while (true) { var files = yield e.next_files_async (10, Priority.DEFAULT, null); if (files == null) { break; } foreach (var info in files) { print ("%s

", info.get_name ()); } } } catch (GLib.Error err) { warning ("Error: %s

", err.message); } } void main () { list_dir.begin (); var loop = new GLib.MainLoop (null, false); loop.run(); }

As you can see, it’s very easy to call the async methods enumerate_children_async and next_files_async in try-catch blocks and loops. There is no need for manually creating structs for user_data or similar inconveniences.

Async methods in Vala can also be used to implement D-Bus servers that can process multiple requests at the same time. Using it couldn’t be easier, just write an async method such as the above example, add it to a class annotated with [DBus (name = “org.example.Test”)], and register an instance of that class with the D-Bus connection. Vala also supports async methods on client-side D-Bus interfaces.