;;;

import "some/path/to/mod" as some_mod;

mod main {
  import "another/path/to/mod" as another_mod;

  export fn a ();
  export fn b () { }
  export let x;

  let y: s32 = 0;
  
  use some_mod.a.b.c.d;
  use some_mod.x.y as q;

  type int: s32;

  struct S1 [ a: s32, b: s32 ]
  struct S2 [ ]
  struct S3;

  union U1 [ a: s32, b: s32 ]
  union U2 [ ]
  union U3;

  enum E1: s32 [ a = 1, b, c = 2 ]
  enum E2 [ a = 1, b = 2 ]
  enum E3: s32;
  enum E4;
  enum E5: s32 [ ]
  enum E6 [ ]

  impl E6 {
    fn to_s32 (^mut self) -> s32 {
      self as _
    }

    fn from_s32 (v: s32) -> Self {
      return v as _;
    }
  }

  fn none () {
    return;
  }

  fn b ((x, y): Q, z: R) -> S {
    let a: s32 = {
      { 1 + 2 + 3 };
      { 2 }
    };

    { 3 & 4 };

    loop {
      func(woot);
    }

    loop {
      func(woot);
    } until false;

    while true {
      if func(woot) { break }
      else { continue }
    }

    for (a, b) in .0..2. {
      func(woot);
    }

    match x {
      = 1...3 => printf("1 to 3\n"),
      = 4...5 => printf("4 to 5\n"),
      _ => printf("not 1 to 3 or 4 to 5\n")
    };

    if x {
      [ 5, 6 ]
    } else if y {
      [ 6, 5 ]
    } else if z {
      [ 4, 4 ]
    } else {
      [ 0, 0 ]
    }
  }
}