switch(expression) 
{
   case 1:
      do_something();
   case 2:
      if (x > 0) nextcase 1; // Jump to 1
      nextcase; // Jump to the next case.
   default:
      foo();
}

struct Test
{
   int x;
   float y;
   String z;
}  

String s = "hello";
String t = `I say "hello"`;

int foo = x ? 1 : 0;

while (int x = foo(); x > 0) 
{
  sum += x;
}

a = b;

fn void foo_typed(int x, int... arg) { ... }
fn void foo_untyped(int x, ...arg) 
...
foo_typed(1, 2, 3);
foo_untyped(1, "hello", 1.2);

module my_module::submodule;
...

fn int IntList.get(IntList* this, int idx) @operator([])
{
   return this.vals[idx];
}
...
IntList x = ...
foo(x[1]);

String s = `this
 string is multiline`;

/* 
  Multiline comment
*/

fn int Foo.get_value(Foo* this)
{
   return this.value;
}

import std::io;

foreach (x : list)
{
  foo(x);
}  

macro square(x)
{
  return x * x;
}

union Foo
{
  int x;
  float f;
  struct 
  {
    char[2] z;
  }  
}  

enum TestEnum : int
{
   FOO,
   BAR,
   BAZ
}

/**
 * @param [in] foo "The foo value"
 * @return "the toal foo count"
 **/

const FOO = 123;
const void* BAR = null;

fn void test(int x = 10) { ... }  

assert(a > 0, "Expected a positive number");
$assert(Foo.sizeof == 8, "Foo sizecheck at compile time failed");

i++; --j;

int x = 314159;

import std::io;
...
io::printf("%d", i);

double d = 3.3;
int x = (int)d;

0b110011

fn void print(String s)
{
   io::printfn("Said: %s", s);
}  
macro @foo(bool run, #lazy)
{
  if (run) #lazy;
}
// Only "Said: Hello" is printed:
@foo(false, print("Bye"));
@foo(true, print("Hello"));

while FOO: (x > 0)
{
  for (int i = 0; i < 10; i++
  {
    x = baz();
    if (x > i) break FOO;
  }
}

"\e\n\r"

int[] slice1 = array[0..5]; // start..end
int[] slice2 = array[0:6]; // start:length

0o177

int i = b << 4 + x; // Same as (b << 4) + x  

// A comment
/* Another comment */

// A comment