# 001 . Syntaxes that will never match
:[X...] X: will never match because syntax lists eat up as much
as they can, so the last element (which is equivalent to the syntax in list)
will always fail to match anything.


# 002 . Auto Parameters need to be explicited in some cases:
  use std
  .:func:.
	let x = 0
	.:sub_1:. {x++}
	.:sub_2:. {sub_1;x} (: would fail without calling x :)


# 003 . Explicit subcall with optional parameter might fail
because explicit subcalls are compiled after syntax matching:
  use std
  .:foobar (<int>) (<real>):.{}
  foobar 123		(:OK:)
  foobar 4.5		(:OK:)
  foobar (x) ;let x=123	(:OK:)
  foobar (y) ;let y=4.5	(:FAIL:)
The same bug with enumerations ( {<int>|<real>} ) however, is fixed.


# 004 . Cyclic dependencies of types without exporting definitions
will cause compilation error:
  (: file a.arg :)
  use std,b ; class A {B b}

  (: file b.arg :)
  use std,a ; class B {A a}
then, when compiling a.arg:
  [...]
  [1] std/class: could not compile type yet
    class B {
      A a;
    }
  [...]
To avoid this kind of problem, you should export all types that may
be used by other files:
  (: file a.arg :)
  use std
  use b exporting :A:
  (: the exporting form of std/use is from std.arg, not implicit :)
  class A {B b}

  (: file b.arg :)
  use std
  use a exporting :B: , :B2:
  class B {A a}
  union B2{int i ; nat n}
  (: B2 needs to be exported if you want another type to depend on it :)
