type ast::expr

An expression

  • :source(Value: ast::expr): string

  • :startline(Value: ast::expr): integer

  • :endline(Value: ast::expr): integer

type ast::expr::and < ast::expr::parent

An and expression

type ast::expr::assign < ast::expr::parent

An assign expression

type ast::expr::blank < ast::expr

A blank expression

type ast::expr::block < ast::expr

A block expression

  • :vars(Value: ast::expr::block): list[ast::local]

  • :lets(Value: ast::expr::block): list[ast::local]

  • :defs(Value: ast::expr::block): list[ast::local]

  • :child(Value: ast::expr::block): list[ast::expr]

  • :catchbody(Value: ast::expr::block): list[ast::expr]

  • :must(Value: ast::expr::block): list[ast::expr]

  • :catchident(Value: ast::expr::block): string

  • :numvars(Value: ast::expr::block): integer

  • :numlets(Value: ast::expr::block): integer

  • :numdefs(Value: ast::expr::block): integer

type ast::expr::call < ast::expr::parent

A call expression

type ast::expr::constcall < ast::expr::parentvalue

A const call expression

type ast::expr::debug < ast::expr::parent

A debug expression

type ast::expr::def < ast::expr::local

A def expression

type ast::expr::default < ast::expr

A default expression

  • :child(Value: ast::expr::default): list[ast::expr]

  • :index(Value: ast::expr::default): integer

  • :flags(Value: ast::expr::default): integer

type ast::expr::defin < ast::expr::local

A def in expression

type ast::expr::define < ast::expr::ident

A define expression

type ast::expr::defunpack < ast::expr::local

A def unpack expression

type ast::expr::delegate < ast::expr::parent

A delegate expression

type ast::expr::each < ast::expr::parent

An each expression

type ast::expr::exit < ast::expr::parent

An exit expression

type ast::expr::for < ast::expr

A for expression

  • :key(Value: ast::expr::for): string

  • :local(Value: ast::expr::for): list[ast::local]

  • :sequence(Value: ast::expr::for): list[ast::expr]

  • :body(Value: ast::expr::for): list[ast::expr]

  • :name(Value: ast::expr::for): string

  • :unpack(Value: ast::expr::for): integer

type ast::expr::fun < ast::expr

A fun expression

  • :name(Value: ast::expr::fun): string

  • :params(Value: ast::expr::fun): list[ast::param]

  • :body(Value: ast::expr::fun): list[ast::expr]

  • :returntype(Value: ast::expr::fun): list[ast::expr]

type ast::expr::guard < ast::expr::parent

A guard expression

type ast::expr::ident < ast::expr

An ident expression

  • :ident(Value: ast::expr::ident): string

type ast::expr::if < ast::expr

An if expression

  • :cases(Value: ast::expr::if): list[ast::ifcase]

  • :else(Value: ast::expr::if): list[ast::expr]

type ast::expr::inline < ast::expr::parent

An inline expression

type ast::expr::it < ast::expr

An it expression

type ast::expr::let < ast::expr::local

A let expression

type ast::expr::letin < ast::expr::local

A let in expression

type ast::expr::letunpack < ast::expr::local

A let unpack expression

type ast::expr::list < ast::expr::parent

A list expression

type ast::expr::local < ast::expr

A local expression

  • :local(Value: ast::expr::local): list[ast::local]

  • :child(Value: ast::expr::local): list[ast::expr]

  • :count(Value: ast::expr::local): integer

type ast::expr::loop < ast::expr::parent

A loop expression

type ast::expr::map < ast::expr::parent

A map expression

type ast::expr::next < ast::expr::parent

A next expression

type ast::expr::nil < ast::expr

A nil expression

type ast::expr::not < ast::expr::parent

A not expression

type ast::expr::old < ast::expr

An old expression

type ast::expr::or < ast::expr::parent

An or expression

type ast::expr::parent < ast::expr

A parent expression

  • :child(Value: ast::expr::parent): list[ast::expr]

  • :name(Value: ast::expr::parent): string

type ast::expr::parentvalue < ast::expr

A parent value expression

  • :child(Value: ast::expr::parentvalue): list[ast::expr]

  • :value(Value: ast::expr::parentvalue): any

type ast::expr::ref < ast::expr::local

A ref expression

type ast::expr::refin < ast::expr::local

A ref in expression

type ast::expr::refunpack < ast::expr::local

A ref unpack expression

type ast::expr::register < ast::expr

A register expression

type ast::expr::resolve < ast::expr::parentvalue

A resolve expression

type ast::expr::return < ast::expr::parent

A return expression

type ast::expr::scoped < ast::expr

A scoped expression

type ast::expr::string < ast::expr

A string expression

  • :parts(Value: ast::expr::string): list[ast::stringpart]

type ast::expr::subst < ast::expr

A subst expression

type ast::expr::suspend < ast::expr::parent

A suspend expression

type ast::expr::switch < ast::expr::parent

A switch expression

type ast::expr::tuple < ast::expr::parent

A tuple expression

type ast::expr::unknown < ast::expr

An unknown expression

type ast::expr::value < ast::expr

A value expression

  • :value(Value: ast::expr::value): any

type ast::expr::var < ast::expr::local

A var expression

type ast::expr::varin < ast::expr::local

A var in expression

type ast::expr::vartype < ast::expr::local

A var type expression

type ast::expr::varunpack < ast::expr::local

A var unpack expression

type ast::expr::with < ast::expr::local

A with expression

type ast::ifcase

An if case

  • :condition(Value: ast::ifcase): list[ast::expr]

  • :body(Value: ast::ifcase): list[ast::expr]

  • :local(Value: ast::ifcase): list[ast::local]

  • :token(Value: ast::ifcase): integer

type ast::local

A local

  • :ident(Value: ast::local): string

  • :line(Value: ast::local): integer

  • :index(Value: ast::local): integer

type ast::names < list


type ast::param

A param

  • :ident(Value: ast::param): string

  • :type(Value: ast::param): list[ast::expr]

  • :line(Value: ast::param): integer

  • :kind(Value: ast::param): ast::paramkind

type ast::stringpart

A string part

  • :child(Value: ast::stringpart): list[ast::expr]

  • :chars(Value: ast::stringpart): string

  • :length(Value: ast::stringpart): integer

  • :line(Value: ast::stringpart): integer

meth (Expr: expr):ast: ast::expr

Returns a tuple describing the expression Expr.

type paramkind < enum