^Syntax
BlockExpression :
   {
      InnerAttribute^*
      Statement^*
      Expression^?
   }

A block expression is similar to a module in terms of the declarations that are possible, but can also contain statements and end with an expression. Each block conceptually introduces a new namespace scope. Use items can bring new names into scopes and declared items are in scope for only the block itself.

A block will execute each statement sequentially, and then execute the expression, if given. If the block doesn't end in an expression, its value is ():

#![allow(unused_variables)]
fn main() {
let x: () = { println!("Hello."); };
}

If it ends in an expression, its value and type are that of the expression:

#![allow(unused_variables)]
fn main() {
let x: i32 = { println!("Hello."); 5 };

assert_eq!(5, x);
}

Blocks are always value expressions and evaluate the last expression in value expression context. This can be used to force moving a value if really needed.

^Syntax
UnsafeBlockExpression :
   unsafe BlockExpression

See unsafe block for more information on when to use unsafe

A block of code can be prefixed with the unsafe keyword, to permit calling unsafe functions or dereferencing raw pointers within a safe function. Examples:

#![allow(unused_variables)]
fn main() {
unsafe {
    let b = [13u8, 17u8];
    let a = &b[0] as *const u8;
    assert_eq!(*a, 13);
    assert_eq!(*a.offset(1), 17);
}

unsafe fn f() -> i32 { 10 }
let a = unsafe { f() };
}