## std.ast: Exposes the AST for building and operating on with macros.

pub type Expr = union
  Ident(string), Number(int), Float(float), Char(chr), String(str)
  Struct(list[tuple[field: str, value: Expr]])
  Tuple(list[tuple[field: string?, value: Expr]])
  List(list[Expr])
  Let(id: Pattern, kind: Type?, value: ref Expr)
  Var(id: Pattern, kind: Type?, value: ref Expr?)
  Const(id: Pattern, kind: Type?, value: ref Expr)
  FuncDecl( # effects?
    id: str,
    generics: list[GenericParams],
    params: list[FunctionParams],
    kind: Type,
    body: list[Expr]
  )
  TypeDecl(id: str, generics: list[str], alias: Type)
  Module(id: str, body: list[Expr])
  Use(path: str)
  Pub(Expr) # can easily generate incoherent statements. still desired?
  Call(id: str, params: list[Expr])
  Cond(branches: list[CondBranch], else_body: list[Expr]?)
  Try(
    try_body: list[Expr],
    catches: list[TryBranch]
    finally_body: list[Expr]?
  )
  Match(
    item: ref Expr,
    branches: list[MatchBranch]
  )
  Block(id: str?, body: list[Expr])
  ConstBlock(body: list[Expr]),
  For(binding: Pattern, range: ref Expr, body: list[Expr])
  While(cond: ref Expr, body: list[Expr])
  Loop(body: list[Expr]),

pub type CondBranch = tuple
  cond: Expr
  body: list[Expr]

pub type TryBranch = tuple
  exceptions: list[str]
  body: list[Expr]

pub type MatchBranch = tuple
  pattern: Pattern
  guard: Option[Expr]
  body: list[Expr]

pub type Type = ref union
  Void, Never,
  Integer, Float, String,
  Func(from: Type, to: Type) # todo: multiple parameters
  Struct(list[tuple[id: str, kind: Type]])
  Tuple(list[tuple[id: str?, kind: Type]])
  Union(list[tuple[id: str, kind: Type]])
  Interface( # todo: generics
    funcs: list[Signature]
    for_type: Type?
  )
  Array(size: uint, kind: Type)
  List(Type)
  Slice(Type) # todo: plus ownership
  Alias(str) # todo: params?? huh?
  Static(Type)
  Mutable(Type)
  Reference(Type)
  Pointer(Type)
pub type Signature = struct # todo: generics
  id: str
  effect: Option[str]
  params: list[Type]
  kind: Option[Type]
pub type Pattern = union
  Ident(str)
  Number(int), Float(float), Char(chr), String(str)
  Struct(name: str, params: list[Pattern])
  Tuple(list[Pattern])
  List(list[Pattern])