A lack of semicolon - is it a bug?

[justanotheranonymoususer]

https://github.com/japaric/rust-by-example/blob/master/examples/tuples/tuples.rs#L33-L34

Two of the last printlns aren't followed by a semicolon. Is it intended?

I'm just learning rust, but why does it even compile? In fact, removing a semicolon from every println call works. Is it because println is a macro?

[japaric]

Two of the last printlns aren't followed by a semicolon. Is it intended?

Not that'd be my omission. It's usual to end println! with a semicolon, although it doesn't really matter.

Is it because println is a macro?

No and yes :-) Let me elaborate.

You can see the expansion of a macro using rustc --pretty expanded foo.rs. For example:

fn main() {
    println!("Hello")

    println!("World");
}

Expands to:

#![feature(phase)]
#![no_std]
#![feature(globs)]
#[phase(plugin, link)]
extern crate std;
extern crate native;
use std::prelude::*;
fn main() {
    match () {
        () => {
            #[allow(dead_code)]
            static __STATIC_FMTSTR: [::std::fmt::rt::Piece<'static>, ..1u] =
                [::std::fmt::rt::String("Hello")];
            let __args_vec = &[];
            let __args =
                unsafe {
                    ::std::fmt::Arguments::new(__STATIC_FMTSTR, __args_vec)
                };

            ::std::io::stdio::println_args(&__args)
        }
    }
    match () {
        () => {
            #[allow(dead_code)]
            static __STATIC_FMTSTR: [::std::fmt::rt::Piece<'static>, ..1u] =
                [::std::fmt::rt::String("World")];
            let __args_vec = &[];
            let __args =
                unsafe {
                    ::std::fmt::Arguments::new(__STATIC_FMTSTR, __args_vec)
                };
            ::std::io::stdio::println_args(&__args)
        }
    };
}

Each println! macro expands to a match expression that returns (), and those don't need to be terminated with a semicolon. That's why you can have many println! statements (one after another) without semicolons at their end.

That's not the case with other macros, for example:

fn main() {
  vec!(1u, 2, 3)
}

Expands to:

#![feature(phase)]
#![no_std]
#![feature(globs)]
#[phase(plugin, link)]
extern crate std;
extern crate native;
use std::prelude::*;
fn main() {
    {
        let mut _temp = ::std::vec::Vec::new();
        _temp.push(1u);
        _temp.push(2);
        _temp.push(3);
        _temp
    }
}

vec! expands to a block that returns a Vec<uint>, and without a semicolon that block expression would be the return value of the main function. Since the signature of main is () -> (), you'll get an error.

TL;DR macros may need to be ended with a semicolon (or not) depending on the implementation.

Hope that helps!

EDIT: Added the part in bold. Originally, when I said "those", I meant the expanded match expressions inside the main function, and not all and every match expression - I should have also mentioned why those two match expressions don't need to be ended with a semicolon; my edit should address those issues. Sorry if that caused confusion, and thanks to @huonw for clarifying the ambiguity in his post.

[justanotheranonymoususer]

I've created a pull request: #191

As for the semicolons, thanks for the explanation. I've created a discussion on Rust's Reddit: http://www.reddit.com/r/rust/comments/2ba3az/macros_writeln_and_the_semicolon/

[huonw]

Each println! macro expands to a match expression, and those don't need to be terminated with a semicolon

This isn't quite true. The semicolon can only be dropped if they return (), i.e. if they are a statement. (In other words, if there is no semicolon, the compiler requires that the type of each arm of the match is ().)

[japaric]

@justanotheranonymoususer #191 has been merged, can we close this?

[justanotheranonymoususer]

Yes, thanks. I do think that this is an issue, but it has nothing to do with rust-by-example. I've created an issue in Rust's repository.