🥮 mooncakes.io
README

moonbitlang/parser/syntax does not have a README file

#
Impls

source

Type List used by this package APIs.

#
Parameters

source

Type List used by this package APIs.

#
TestName

source

#
IterVisitor

source
pub(open) trait IterVisitor {
  fn base(Self) -> IterVisitorBase[Self] = _
  fn visit_Visibility(Self, Visibility) -> Unit = _
  fn visit_Visibility_Pub(Self, attr~ : String?, loc~ : 
Location) -> Unit = _
  fn visit_Visibility_Priv(Self, loc~ : 
Location) -> Unit = _
  fn visit_Constant(Self, Constant) -> Unit = _
  fn visit_Label(Self, Label) -> Unit = _
  fn visit_ConstrName(Self, ConstrName) -> Unit = _
  fn visit_LongIdent(Self, LongIdent) -> Unit = _
  fn visit_LongIdent_Ident(Self, name~ : String) -> Unit = _
  fn visit_LongIdent_Dot(Self, pkg~ : String, id~ : String) -> Unit = _
  fn visit_TypeName(Self, TypeName) -> Unit = _
  fn visit_ConstrId(Self, ConstrId) -> Unit = _
  fn visit_Type(Self, Type) -> Unit = _
  fn visit_Type_Any(Self, loc~ : 
Location) -> Unit = _
  fn visit_Type_Arrow(Self, args~ : 
List[Type], res~ : Type, err~ : ErrorType, is_async~ : 
Location?, loc~ : 
Location) -> Unit = _
  fn visit_Type_Name(Self, constr_id~ : ConstrId, tys~ : 
List[Type], loc~ : 
Location) -> Unit = _
  fn visit_Type_Tuple(Self, tys~ : 
List[Type], loc~ : 
Location) -> Unit = _
  fn visit_Type_Option(Self, ty~ : Type, loc~ : 
Location, question_loc~ : 
Location) -> Unit = _
  fn visit_Type_Object(Self, ConstrId) -> Unit = _
  fn visit_ErrorType(Self, ErrorType) -> Unit = _
  fn visit_ErrorType_ErrorType(Self, ty~ : Type) -> Unit = _
  fn visit_ErrorType_DefaultErrorType(Self, loc~ : 
Location) -> Unit = _
  fn visit_ErrorType_Noraise(Self, loc~ : 
Location) -> Unit = _
  fn visit_ErrorType_MaybeError(Self, ty~ : Type) -> Unit = _
  fn visit_ConstrParam(Self, ConstrParam) -> Unit = _
  fn visit_ConstrDecl(Self, ConstrDecl) -> Unit = _
  fn visit_ExceptionDecl(Self, ExceptionDecl) -> Unit = _
  fn visit_ExceptionDecl_EnumPayload(Self, 
List[ConstrDecl]) -> Unit = _
  fn visit_FieldName(Self, FieldName) -> Unit = _
  fn visit_FieldDecl(Self, FieldDecl) -> Unit = _
  fn visit_TypeDesc(Self, TypeDesc) -> Unit = _
  fn visit_TypeDesc_Error(Self, ExceptionDecl) -> Unit = _
  fn visit_TypeDesc_Variant(Self, 
List[ConstrDecl]) -> Unit = _
  fn visit_TypeDesc_Record(Self, fields~ : 
List[FieldDecl]) -> Unit = _
  fn visit_TypeDesc_TupleStruct(Self, 
List[Type]) -> Unit = _
  fn visit_TypeDesc_Alias(Self, Type) -> Unit = _
  fn visit_Hole(Self, Hole) -> Unit = _
  fn visit_ArgumentKind(Self, ArgumentKind) -> Unit = _
  fn visit_ArgumentKind_Labelled(Self, Label) -> Unit = _
  fn visit_ArgumentKind_LabelledPun(Self, Label) -> Unit = _
  fn visit_ArgumentKind_LabelledOption(Self, label~ : Label, question_loc~ : 
Location) -> Unit = _
  fn visit_ArgumentKind_LabelledOptionPun(Self, label~ : Label, question_loc~ : 
Location) -> Unit = _
  fn visit_FnKind(Self, FnKind) -> Unit = _
  fn visit_Group(Self, Group) -> Unit = _
  fn visit_TrailingMark(Self, TrailingMark) -> Unit = _
  fn visit_TypeVarConstraint(Self, TypeVarConstraint) -> Unit = _
  fn visit_TypeVarBinder(Self, TypeVarBinder) -> Unit = _
  fn visit_TypeDeclBinder(Self, TypeDeclBinder) -> Unit = _
  fn visit_Binder(Self, Binder) -> Unit = _
  fn visit_Var(Self, Var) -> Unit = _
  fn visit_ConstructorExtraInfo(Self, ConstructorExtraInfo) -> Unit = _
  fn visit_ConstructorExtraInfo_TypeName(Self, TypeName) -> Unit = _
  fn visit_ConstructorExtraInfo_Package(Self, String) -> Unit = _
  fn visit_Constructor(Self, Constructor) -> Unit = _
  fn visit_Accessor(Self, Accessor) -> Unit = _
  fn visit_Accessor_Label(Self, Label) -> Unit = _
  fn visit_Accessor_Index(Self, tuple_index~ : Int, loc~ : 
Location) -> Unit = _
  fn visit_Accessor_Newtype(Self, loc~ : 
Location) -> Unit = _
  fn visit_AliasTarget(Self, AliasTarget) -> Unit = _
  fn visit_Argument(Self, Argument) -> Unit = _
  fn visit_Parameter(Self, Parameter) -> Unit = _
  fn visit_Parameter_DiscardPositional(Self, ty~ : Type?, loc~ : 
Location) -> Unit = _
  fn visit_Parameter_Positional(Self, binder~ : Binder, ty~ : Type?) -> Unit = _
  fn visit_Parameter_Labelled(Self, binder~ : Binder, ty~ : Type?) -> Unit = _
  fn visit_Parameter_Optional(Self, binder~ : Binder, default~ : Expr, ty~ : Type?) -> Unit = _
  fn visit_Parameter_QuestionOptional(Self, binder~ : Binder, ty~ : Type?) -> Unit = _
  fn visit_Case(Self, Case) -> Unit = _
  fn visit_LexCase(Self, LexCase) -> Unit = _
  fn visit_LexTopPattern(Self, LexTopPattern) -> Unit = _
  fn visit_LexTopPattern_Pattern(Self, LexPattern) -> Unit = _
  fn visit_LexTopPattern_Binder(Self, Binder) -> Unit = _
  fn visit_LexTopPattern_Wildcard(Self, loc~ : 
Location) -> Unit = _
  fn visit_LexPattern(Self, LexPattern) -> Unit = _
  fn visit_LexPattern_Regex(Self, lit~ : String, offset~ : Int, loc~ : 
Location) -> Unit = _
  fn visit_LexPattern_RegexInterp(Self, elems~ : 
List[InterpElem], loc~ : 
Location) -> Unit = _
  fn visit_LexPattern_ConstantRef(Self, lid~ : LongIdent, loc~ : 
Location) -> Unit = _
  fn visit_LexPattern_Alias(Self, pat~ : LexPattern, binder~ : Binder, loc~ : 
Location) -> Unit = _
  fn visit_LexPattern_Sequence(Self, pats~ : 
List[LexPattern], loc~ : 
Location) -> Unit = _
  fn visit_SpreadableElem(Self, SpreadableElem) -> Unit = _
  fn visit_SpreadableElem_Regular(Self, Expr) -> Unit = _
  fn visit_SpreadableElem_Spread(Self, expr~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_MapExprElem(Self, MapExprElem) -> Unit = _
  fn visit_StaticAssertion(Self, StaticAssertion) -> Unit = _
  fn visit_Func(Self, Func) -> Unit = _
  fn visit_FieldDef(Self, FieldDef) -> Unit = _
  fn visit_InterpElem(Self, InterpElem) -> Unit = _
  fn visit_InterpElem_Literal(Self, repr~ : String, loc~ : 
Location) -> Unit = _
  fn visit_InterpElem_Expr(Self, expr~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_InterpElem_Source(Self, 
InterpSource) -> Unit = _
  fn visit_MultilineStringElem(Self, MultilineStringElem) -> Unit = _
  fn visit_MultilineStringElem_String(Self, String) -> Unit = _
  fn visit_MultilineStringElem_Interp(Self, 
List[InterpElem]) -> Unit = _
  fn visit_TryOperatorKind(Self, TryOperatorKind) -> Unit = _
  fn visit_DotDotBinder(Self, DotDotBinder) -> Unit = _
  fn visit_DotDotBinder_BinderAs(Self, Binder) -> Unit = _
  fn visit_DotDotBinder_Binder(Self, Binder) -> Unit = _
  fn visit_ArrayPattern(Self, ArrayPattern) -> Unit = _
  fn visit_ArrayPattern_Pattern(Self, Pattern) -> Unit = _
  fn visit_ArrayPattern_StringSpread(Self, str~ : String, loc~ : 
Location) -> Unit = _
  fn visit_ArrayPattern_BytesSpread(Self, bytes~ : String, loc~ : 
Location) -> Unit = _
  fn visit_ArrayPattern_ConstSpread(Self, binder~ : Binder, pkg~ : String?, loc~ : 
Location) -> Unit = _
  fn visit_ArrayPatterns(Self, ArrayPatterns) -> Unit = _
  fn visit_ArrayPatterns_Closed(Self, 
List[ArrayPattern]) -> Unit = _
  fn visit_ArrayPatterns_Open(Self, 
List[ArrayPattern], 
List[ArrayPattern], DotDotBinder) -> Unit = _
  fn visit_WhereClause(Self, WhereClause) -> Unit = _
  fn visit_FieldPat(Self, FieldPat) -> Unit = _
  fn visit_ConstrPatArg(Self, ConstrPatArg) -> Unit = _
  fn visit_MapPatElem(Self, MapPatElem) -> Unit = _
  fn visit_RangeKind(Self, RangeKind) -> Unit = _
  fn visit_Pattern(Self, Pattern) -> Unit = _
  fn visit_Pattern_Alias(Self, pat~ : Pattern, alias_~ : Binder, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Any(Self, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Array(Self, pats~ : ArrayPatterns, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Constant(Self, c~ : Constant, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Constraint(Self, pat~ : Pattern, ty~ : Type, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Constr(Self, constr~ : Constructor, args~ : 
List[ConstrPatArg]?, is_open~ : Bool, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Or(Self, pat1~ : Pattern, pat2~ : Pattern, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Tuple(Self, pats~ : 
List[Pattern], loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Var(Self, Binder) -> Unit = _
  fn visit_Pattern_Record(Self, fields~ : 
List[FieldPat], is_closed~ : Bool, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Map(Self, elems~ : 
List[MapPatElem], is_closed~ : Bool, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_Range(Self, lhs~ : Pattern, rhs~ : Pattern, kind~ : RangeKind, loc~ : 
Location) -> Unit = _
  fn visit_Pattern_With(Self, pat~ : Pattern, bindings~ : 
List[(Binder, Expr)], loc~ : 
Location) -> Unit = _
  fn visit_Pattern_SpecialConstr(Self, binder~ : Binder, args~ : 
List[ConstrPatArg], loc~ : 
Location) -> Unit = _
  fn visit_DerivingDirective(Self, DerivingDirective) -> Unit = _
  fn visit_TypeDecl(Self, TypeDecl) -> Unit = _
  fn visit_FuncStubs(Self, FuncStubs) -> Unit = _
  fn visit_FuncStubs_Import(Self, module_name~ : String, func_name~ : String, language~ : String?) -> Unit = _
  fn visit_FuncStubs_Embedded(Self, language~ : String?, code~ : EmbeddedCode) -> Unit = _
  fn visit_EmbeddedCode(Self, EmbeddedCode) -> Unit = _
  fn visit_EmbeddedCode_CodeString(Self, String) -> Unit = _
  fn visit_EmbeddedCode_CodeMultilineString(Self, 
List[String]) -> Unit = _
  fn visit_DeclBody(Self, DeclBody) -> Unit = _
  fn visit_DeclBody_DeclBody(Self, expr~ : Expr) -> Unit = _
  fn visit_DeclBody_DeclStubs(Self, FuncStubs) -> Unit = _
  fn visit_FunDecl(Self, FunDecl) -> Unit = _
  fn visit_TraitMethodDecl(Self, TraitMethodDecl) -> Unit = _
  fn visit_TraitDecl(Self, TraitDecl) -> Unit = _
  fn visit_Impl(Self, Impl) -> Unit = _
  fn visit_Impl_TopExpr(Self, expr~ : Expr, is_main~ : Bool, is_async~ : 
Location?, loc~ : 
Location) -> Unit = _
  fn visit_Impl_TopTest(Self, expr~ : Expr, name~ : (String, 
Location)?, params~ : 
List[Parameter]?, is_async~ : 
Location?, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString) -> Unit = _
  fn visit_Impl_TopTypeDef(Self, TypeDecl) -> Unit = _
  fn visit_Impl_TopFuncDef(Self, fun_decl~ : FunDecl, decl_body~ : DeclBody, where_clause~ : WhereClause?, loc~ : 
Location) -> Unit = _
  fn visit_Impl_TopLetDef(Self, binder~ : Binder, ty~ : Type?, expr~ : Expr, vis~ : Visibility, is_constant~ : Bool, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString, is_declare~ : Bool) -> Unit = _
  fn visit_Impl_TopTrait(Self, TraitDecl) -> Unit = _
  fn visit_Impl_TopImpl(Self, self_ty~ : Type?, trait_~ : TypeName, method_name~ : Binder, quantifiers~ : 
List[TypeVarBinder], method_quantifiers~ : 
List[TypeVarBinder], params~ : 
List[Parameter], ret_ty~ : Type?, err_ty~ : ErrorType, body~ : DeclBody, vis~ : Visibility, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString) -> Unit = _
  fn visit_Impl_TopView(Self, quantifiers~ : 
List[TypeVarBinder], source_ty~ : Type, view_type_name~ : String, view_type_loc~ : 
Location, view_constrs~ : 
List[ConstrDecl], view_func_name~ : Binder, parameters~ : 
List[Parameter], params_loc~ : 
Location, body~ : Expr, vis~ : Visibility, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString) -> Unit = _
  fn visit_Impl_TopImplRelation(Self, self_ty~ : Type, trait_~ : TypeName, quantifiers~ : 
List[TypeVarBinder], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, doc~ : DocString, is_declare~ : Bool) -> Unit = _
  fn visit_Impl_TopUsing(Self, pkg~ : Label, names~ : 
List[(AliasTarget, UsingKind)], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, doc~ : DocString) -> Unit = _
  fn visit_Impl_TopExtend(Self, type_name~ : TypeName, trait_~ : TypeName, names~ : 
List[AliasTarget], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, doc~ : DocString) -> Unit = _
  fn visit_Impl_TopImport(Self, kind~ : String?, packages~ : 
List[ImportPackage], loc~ : 
Location, doc~ : DocString) -> Unit = _
  fn visit_UsingKind(Self, UsingKind) -> Unit = _
  fn visit_ImportPackage(Self, ImportPackage) -> Unit = _
  fn visit_Expr(Self, Expr) -> Unit = _
  fn visit_Expr_Apply(Self, func~ : Expr, args~ : 
List[Argument], loc~ : 
Location) -> Unit = _
  fn visit_Expr_Infix(Self, op~ : Var, lhs~ : Expr, rhs~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Unary(Self, op~ : Var, expr~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Array(Self, exprs~ : 
List[Expr], is_iter~ : Bool, loc~ : 
Location) -> Unit = _
  fn visit_Expr_ArraySpread(Self, elems~ : 
List[SpreadableElem], is_iter~ : Bool, loc~ : 
Location) -> Unit = _
  fn visit_Expr_ArrayGet(Self, array~ : Expr, index~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_ArrayGetSlice(Self, array~ : Expr, start_index~ : Expr?, end_index~ : Expr?, index_loc~ : 
Location, loc~ : 
Location) -> Unit = _
  fn visit_Expr_ArraySet(Self, array~ : Expr, index~ : Expr, value~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_ArrayAugmentedSet(Self, op~ : Var, array~ : Expr, index~ : Expr, value~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Constant(Self, c~ : Constant, loc~ : 
Location) -> Unit = _
  fn visit_Expr_MultilineString(Self, elems~ : 
List[MultilineStringElem], loc~ : 
Location) -> Unit = _
  fn visit_Expr_Interp(Self, elems~ : 
List[InterpElem], loc~ : 
Location) -> Unit = _
  fn visit_Expr_BytesInterp(Self, elems~ : 
List[InterpElem], loc~ : 
Location) -> Unit = _
  fn visit_Expr_Constraint(Self, expr~ : Expr, ty~ : Type, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Constr(Self, constr~ : Constructor, loc~ : 
Location) -> Unit = _
  fn visit_Expr_LabelledBlock(Self, label~ : Label, body~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_While(Self, loop_cond~ : Expr, loop_body~ : Expr, while_else~ : Expr?, label~ : Label?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Function(Self, func~ : Func, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Ident(Self, id~ : Var, loc~ : 
Location) -> Unit = _
  fn visit_Expr_If(Self, cond~ : Expr, ifso~ : Expr, ifnot~ : Expr?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Guard(Self, cond~ : Expr, otherwise~ : Expr?, body~ : Expr, exclamation~ : Bool, guard_loc~ : 
Location, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Is(Self, expr~ : Expr, pat~ : Pattern, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Defer(Self, expr~ : Expr, body~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_LetFn(Self, name~ : Binder, func~ : Func, body~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_LetAnd(Self, bindings~ : 
List[(Binder, Type?, Func)], body~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Let(Self, pattern~ : Pattern, expr~ : Expr, body~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Sequence(Self, exprs~ : 
List[Expr], last_expr~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Tuple(Self, exprs~ : 
List[Expr], loc~ : 
Location) -> Unit = _
  fn visit_Expr_Record(Self, type_name~ : TypeName?, fields~ : 
List[FieldDef], trailing~ : TrailingMark, loc~ : 
Location) -> Unit = _
  fn visit_Expr_RecordUpdate(Self, type_name~ : TypeName?, record~ : Expr, fields~ : 
List[FieldDef], loc~ : 
Location) -> Unit = _
  fn visit_Expr_Field(Self, record~ : Expr, accessor~ : Accessor, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Method(Self, type_name~ : TypeName, method_name~ : Label, loc~ : 
Location) -> Unit = _
  fn visit_Expr_DotApply(Self, self~ : Expr, method_name~ : Label, args~ : 
List[Argument], return_self~ : Bool, loc~ : 
Location) -> Unit = _
  fn visit_Expr_As(Self, expr~ : Expr, trait_~ : TypeName, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Mutate(Self, record~ : Expr, accessor~ : Accessor, field~ : Expr, augmented_by~ : Var?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Match(Self, expr~ : Expr, cases~ : 
List[Case], match_loc~ : 
Location, loc~ : 
Location) -> Unit = _
  fn visit_Expr_LexMatch(Self, strategy~ : Label?, expr~ : Expr, match_loc~ : 
Location, cases~ : 
List[LexCase], loc~ : 
Location) -> Unit = _
  fn visit_Expr_LexScan(Self, strategy~ : Label?, expr~ : Expr, match_loc~ : 
Location, cases~ : 
List[LexScanCase], loc~ : 
Location) -> Unit = _
  fn visit_LexScanCase(Self, LexScanCase) -> Unit = _
  fn visit_LexScanCasePattern(Self, LexScanCasePattern) -> Unit = _
  fn visit_LexScanCasePattern_Pattern(Self, RegexPattern) -> Unit = _
  fn visit_LexScanCasePattern_Binder(Self, Binder) -> Unit = _
  fn visit_LexScanCasePattern_Wildcard(Self, loc~ : 
Location) -> Unit = _
  fn visit_Expr_LetMut(Self, binder~ : Binder, ty~ : Type?, expr~ : Expr, body~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Pipe(Self, lhs~ : Expr, rhs~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Assign(Self, var_~ : Var, expr~ : Expr, augmented_by~ : Var?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Hole(Self, loc~ : 
Location, kind~ : Hole) -> Unit = _
  fn visit_Expr_Return(Self, return_value~ : Expr?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Raise(Self, err_value~ : Expr, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Unit(Self, loc~ : 
Location, faked~ : Bool) -> Unit = _
  fn visit_Expr_Break(Self, arg~ : Expr?, label~ : Label?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Continue(Self, args~ : 
List[Expr], label~ : Label?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_For(Self, binders~ : 
List[(Binder, Expr)], condition~ : Expr?, continue_block~ : 
List[(Binder, Expr)], body~ : Expr, for_else~ : Expr?, label~ : Label?, loc~ : 
Location, where_clause~ : WhereClause?) -> Unit = _
  fn visit_Expr_ForEach(Self, binders~ : 
List[Binder?], expr~ : Expr, init~ : 
List[(Binder, Expr)], continue_block~ : 
List[(Binder, Expr)], body~ : Expr, else_block~ : Expr?, where_clause~ : WhereClause?, label~ : Label?, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Try(Self, body~ : Expr, catch_~ : 
List[Case], try_else~ : 
List[Case]?, has_try~ : Bool, try_loc~ : 
Location, catch_loc~ : 
Location, else_loc~ : 
Location, loc~ : 
Location) -> Unit = _
  fn visit_Expr_TryOperator(Self, body~ : Expr, kind~ : TryOperatorKind, try_loc~ : 
Location, loc~ : 
Location) -> Unit = _
  fn visit_Expr_Map(Self, elems~ : 
List[MapExprElem], loc~ : 
Location) -> Unit = _
  fn visit_Expr_Group(Self, expr~ : Expr, group~ : Group, loc~ : 
Location) -> Unit = _
  fn visit_Expr_StaticAssert(Self, asserts~ : 
List[StaticAssertion], body~ : Expr) -> Unit = _
}

#
MapVisitor

source
pub(open) trait MapVisitor {
  fn base(Self) -> MapVisitorBase[Self] = _
  fn visit_Visibility(Self, Visibility) -> Visibility = _
  fn visit_Visibility_Pub(Self, attr~ : String?, loc~ : 
Location) -> Visibility = _
  fn visit_Visibility_Priv(Self, loc~ : 
Location) -> Visibility = _
  fn visit_Constant(Self, Constant) -> Constant = _
  fn visit_Label(Self, Label) -> Label = _
  fn visit_ConstrName(Self, ConstrName) -> ConstrName = _
  fn visit_LongIdent(Self, LongIdent) -> LongIdent = _
  fn visit_LongIdent_Ident(Self, name~ : String) -> LongIdent = _
  fn visit_LongIdent_Dot(Self, pkg~ : String, id~ : String) -> LongIdent = _
  fn visit_TypeName(Self, TypeName) -> TypeName = _
  fn visit_ConstrId(Self, ConstrId) -> ConstrId = _
  fn visit_Type(Self, Type) -> Type = _
  fn visit_Type_Any(Self, loc~ : 
Location) -> Type = _
  fn visit_Type_Arrow(Self, args~ : 
List[Type], res~ : Type, err~ : ErrorType, is_async~ : 
Location?, loc~ : 
Location) -> Type = _
  fn visit_Type_Tuple(Self, tys~ : 
List[Type], loc~ : 
Location) -> Type = _
  fn visit_Type_Name(Self, constr_id~ : ConstrId, tys~ : 
List[Type], loc~ : 
Location) -> Type = _
  fn visit_Type_Option(Self, ty~ : Type, loc~ : 
Location, question_loc~ : 
Location) -> Type = _
  fn visit_Type_Object(Self, ConstrId) -> Type = _
  fn visit_ErrorType(Self, ErrorType) -> ErrorType = _
  fn visit_ErrorType_ErrorType(Self, ty~ : Type) -> ErrorType = _
  fn visit_ErrorType_DefaultErrorType(Self, loc~ : 
Location) -> ErrorType = _
  fn visit_ErrorType_Noraise(Self, loc~ : 
Location) -> ErrorType = _
  fn visit_ErrorType_MaybeError(Self, ty~ : Type) -> ErrorType = _
  fn visit_ConstrParam(Self, ConstrParam) -> ConstrParam = _
  fn visit_ConstrDecl(Self, ConstrDecl) -> ConstrDecl = _
  fn visit_ExceptionDecl(Self, ExceptionDecl) -> ExceptionDecl = _
  fn visit_ExceptionDecl_EnumPayload(Self, 
List[ConstrDecl]) -> ExceptionDecl = _
  fn visit_FieldName(Self, FieldName) -> FieldName = _
  fn visit_FieldDecl(Self, FieldDecl) -> FieldDecl = _
  fn visit_TypeDesc(Self, TypeDesc) -> TypeDesc = _
  fn visit_TypeDesc_Error(Self, ExceptionDecl) -> TypeDesc = _
  fn visit_TypeDesc_Variant(Self, 
List[ConstrDecl]) -> TypeDesc = _
  fn visit_TypeDesc_Record(Self, fields~ : 
List[FieldDecl]) -> TypeDesc = _
  fn visit_TypeDesc_TupleStruct(Self, 
List[Type]) -> TypeDesc = _
  fn visit_TypeDesc_Alias(Self, Type) -> TypeDesc = _
  fn visit_Hole(Self, Hole) -> Hole = _
  fn visit_ArgumentKind(Self, ArgumentKind) -> ArgumentKind = _
  fn visit_ArgumentKind_Labelled(Self, Label) -> ArgumentKind = _
  fn visit_ArgumentKind_LabelledPun(Self, Label) -> ArgumentKind = _
  fn visit_ArgumentKind_LabelledOption(Self, label~ : Label, question_loc~ : 
Location) -> ArgumentKind = _
  fn visit_ArgumentKind_LabelledOptionPun(Self, label~ : Label, question_loc~ : 
Location) -> ArgumentKind = _
  fn visit_FnKind(Self, FnKind) -> FnKind = _
  fn visit_Group(Self, Group) -> Group = _
  fn visit_TrailingMark(Self, TrailingMark) -> TrailingMark = _
  fn visit_TypeVarConstraint(Self, TypeVarConstraint) -> TypeVarConstraint = _
  fn visit_TypeVarBinder(Self, TypeVarBinder) -> TypeVarBinder = _
  fn visit_TypeDeclBinder(Self, TypeDeclBinder) -> TypeDeclBinder = _
  fn visit_Binder(Self, Binder) -> Binder = _
  fn visit_Var(Self, Var) -> Var = _
  fn visit_ConstructorExtraInfo(Self, ConstructorExtraInfo) -> ConstructorExtraInfo = _
  fn visit_ConstructorExtraInfo_TypeName(Self, TypeName) -> ConstructorExtraInfo = _
  fn visit_ConstructorExtraInfo_Package(Self, String) -> ConstructorExtraInfo = _
  fn visit_Constructor(Self, Constructor) -> Constructor = _
  fn visit_Accessor(Self, Accessor) -> Accessor = _
  fn visit_Accessor_Label(Self, Label) -> Accessor = _
  fn visit_Accessor_Index(Self, tuple_index~ : Int, loc~ : 
Location) -> Accessor = _
  fn visit_Accessor_Newtype(Self, loc~ : 
Location) -> Accessor = _
  fn visit_AliasTarget(Self, AliasTarget) -> AliasTarget = _
  fn visit_Argument(Self, Argument) -> Argument = _
  fn visit_Parameter(Self, Parameter) -> Parameter = _
  fn visit_Parameter_DiscardPositional(Self, ty~ : Type?, loc~ : 
Location) -> Parameter = _
  fn visit_Parameter_Positional(Self, binder~ : Binder, ty~ : Type?) -> Parameter = _
  fn visit_Parameter_Labelled(Self, binder~ : Binder, ty~ : Type?) -> Parameter = _
  fn visit_Parameter_Optional(Self, binder~ : Binder, default~ : Expr, ty~ : Type?) -> Parameter = _
  fn visit_Parameter_QuestionOptional(Self, binder~ : Binder, ty~ : Type?) -> Parameter = _
  fn visit_Case(Self, Case) -> Case = _
  fn visit_LexCase(Self, LexCase) -> LexCase = _
  fn visit_LexTopPattern(Self, LexTopPattern) -> LexTopPattern = _
  fn visit_LexTopPattern_Pattern(Self, LexPattern) -> LexTopPattern = _
  fn visit_LexTopPattern_Binder(Self, Binder) -> LexTopPattern = _
  fn visit_LexTopPattern_Wildcard(Self, loc~ : 
Location) -> LexTopPattern = _
  fn visit_LexPattern(Self, LexPattern) -> LexPattern = _
  fn visit_LexPattern_Regex(Self, lit~ : String, offset~ : Int, loc~ : 
Location) -> LexPattern = _
  fn visit_LexPattern_RegexInterp(Self, elems~ : 
List[InterpElem], loc~ : 
Location) -> LexPattern = _
  fn visit_LexPattern_ConstantRef(Self, lid~ : LongIdent, loc~ : 
Location) -> LexPattern = _
  fn visit_LexPattern_Alias(Self, pat~ : LexPattern, binder~ : Binder, loc~ : 
Location) -> LexPattern = _
  fn visit_LexPattern_Sequence(Self, pats~ : 
List[LexPattern], loc~ : 
Location) -> LexPattern = _
  fn visit_SpreadableElem(Self, SpreadableElem) -> SpreadableElem = _
  fn visit_SpreadableElem_Regular(Self, Expr) -> SpreadableElem = _
  fn visit_SpreadableElem_Spread(Self, expr~ : Expr, loc~ : 
Location) -> SpreadableElem = _
  fn visit_MapExprElem(Self, MapExprElem) -> MapExprElem = _
  fn visit_StaticAssertion(Self, StaticAssertion) -> StaticAssertion = _
  fn visit_Func(Self, Func) -> Func = _
  fn visit_FieldDef(Self, FieldDef) -> FieldDef = _
  fn visit_InterpElem(Self, InterpElem) -> InterpElem = _
  fn visit_InterpElem_Literal(Self, repr~ : String, loc~ : 
Location) -> InterpElem = _
  fn visit_InterpElem_Expr(Self, expr~ : Expr, loc~ : 
Location) -> InterpElem = _
  fn visit_InterpElem_Source(Self, 
InterpSource) -> InterpElem = _
  fn visit_MultilineStringElem(Self, MultilineStringElem) -> MultilineStringElem = _
  fn visit_MultilineStringElem_String(Self, String) -> MultilineStringElem = _
  fn visit_MultilineStringElem_Interp(Self, 
List[InterpElem]) -> MultilineStringElem = _
  fn visit_TryOperatorKind(Self, TryOperatorKind) -> TryOperatorKind = _
  fn visit_DotDotBinder(Self, DotDotBinder) -> DotDotBinder = _
  fn visit_DotDotBinder_BinderAs(Self, Binder) -> DotDotBinder = _
  fn visit_DotDotBinder_Binder(Self, Binder) -> DotDotBinder = _
  fn visit_ArrayPattern(Self, ArrayPattern) -> ArrayPattern = _
  fn visit_ArrayPattern_Pattern(Self, Pattern) -> ArrayPattern = _
  fn visit_ArrayPattern_StringSpread(Self, str~ : String, loc~ : 
Location) -> ArrayPattern = _
  fn visit_ArrayPattern_BytesSpread(Self, bytes~ : String, loc~ : 
Location) -> ArrayPattern = _
  fn visit_ArrayPattern_ConstSpread(Self, binder~ : Binder, pkg~ : String?, loc~ : 
Location) -> ArrayPattern = _
  fn visit_ArrayPatterns(Self, ArrayPatterns) -> ArrayPatterns = _
  fn visit_ArrayPatterns_Closed(Self, 
List[ArrayPattern]) -> ArrayPatterns = _
  fn visit_ArrayPatterns_Open(Self, 
List[ArrayPattern], 
List[ArrayPattern], DotDotBinder) -> ArrayPatterns = _
  fn visit_WhereClause(Self, WhereClause) -> WhereClause = _
  fn visit_FieldPat(Self, FieldPat) -> FieldPat = _
  fn visit_ConstrPatArg(Self, ConstrPatArg) -> ConstrPatArg = _
  fn visit_MapPatElem(Self, MapPatElem) -> MapPatElem = _
  fn visit_RangeKind(Self, RangeKind) -> RangeKind = _
  fn visit_Pattern(Self, Pattern) -> Pattern = _
  fn visit_Pattern_Alias(Self, pat~ : Pattern, alias_~ : Binder, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Any(Self, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Array(Self, pats~ : ArrayPatterns, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Constant(Self, c~ : Constant, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Constraint(Self, pat~ : Pattern, ty~ : Type, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Constr(Self, constr~ : Constructor, args~ : 
List[ConstrPatArg]?, is_open~ : Bool, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Or(Self, pat1~ : Pattern, pat2~ : Pattern, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Tuple(Self, pats~ : 
List[Pattern], loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Var(Self, Binder) -> Pattern = _
  fn visit_Pattern_Record(Self, fields~ : 
List[FieldPat], is_closed~ : Bool, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Map(Self, elems~ : 
List[MapPatElem], is_closed~ : Bool, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_Range(Self, lhs~ : Pattern, rhs~ : Pattern, kind~ : RangeKind, loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_With(Self, pat~ : Pattern, bindings~ : 
List[(Binder, Expr)], loc~ : 
Location) -> Pattern = _
  fn visit_Pattern_SpecialConstr(Self, binder~ : Binder, args~ : 
List[ConstrPatArg], loc~ : 
Location) -> Pattern = _
  fn visit_DerivingDirective(Self, DerivingDirective) -> DerivingDirective = _
  fn visit_TypeDecl(Self, TypeDecl) -> TypeDecl = _
  fn visit_FuncStubs(Self, FuncStubs) -> FuncStubs = _
  fn visit_FuncStubs_Import(Self, module_name~ : String, func_name~ : String, language~ : String?) -> FuncStubs = _
  fn visit_FuncStubs_Embedded(Self, language~ : String?, code~ : EmbeddedCode) -> FuncStubs = _
  fn visit_EmbeddedCode(Self, EmbeddedCode) -> EmbeddedCode = _
  fn visit_EmbeddedCode_CodeString(Self, String) -> EmbeddedCode = _
  fn visit_EmbeddedCode_CodeMultilineString(Self, 
List[String]) -> EmbeddedCode = _
  fn visit_DeclBody(Self, DeclBody) -> DeclBody = _
  fn visit_DeclBody_DeclBody(Self, expr~ : Expr) -> DeclBody = _
  fn visit_DeclBody_DeclStubs(Self, FuncStubs) -> DeclBody = _
  fn visit_FunDecl(Self, FunDecl) -> FunDecl = _
  fn visit_TraitMethodDecl(Self, TraitMethodDecl) -> TraitMethodDecl = _
  fn visit_TraitDecl(Self, TraitDecl) -> TraitDecl = _
  fn visit_UsingKind(Self, UsingKind) -> UsingKind = _
  fn visit_ImportPackage(Self, ImportPackage) -> ImportPackage = _
  fn visit_Impl(Self, Impl) -> Impl = _
  fn visit_Impl_TopExpr(Self, expr~ : Expr, is_main~ : Bool, is_async~ : 
Location?, loc~ : 
Location) -> Impl = _
  fn visit_Impl_TopTest(Self, expr~ : Expr, name~ : (String, 
Location)?, params~ : 
List[Parameter]?, is_async~ : 
Location?, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString) -> Impl = _
  fn visit_Impl_TopTypeDef(Self, TypeDecl) -> Impl = _
  fn visit_Impl_TopFuncDef(Self, fun_decl~ : FunDecl, decl_body~ : DeclBody, where_clause~ : WhereClause?, loc~ : 
Location) -> Impl = _
  fn visit_Impl_TopLetDef(Self, binder~ : Binder, ty~ : Type?, expr~ : Expr, vis~ : Visibility, is_constant~ : Bool, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString, is_declare~ : Bool) -> Impl = _
  fn visit_Impl_TopTrait(Self, TraitDecl) -> Impl = _
  fn visit_Impl_TopImpl(Self, self_ty~ : Type?, trait_~ : TypeName, method_name~ : Binder, quantifiers~ : 
List[TypeVarBinder], method_quantifiers~ : 
List[TypeVarBinder], params~ : 
List[Parameter], ret_ty~ : Type?, err_ty~ : ErrorType, body~ : DeclBody, vis~ : Visibility, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString) -> Impl = _
  fn visit_Impl_TopView(Self, quantifiers~ : 
List[TypeVarBinder], source_ty~ : Type, view_type_name~ : String, view_type_loc~ : 
Location, view_constrs~ : 
List[ConstrDecl], view_func_name~ : Binder, parameters~ : 
List[Parameter], params_loc~ : 
Location, body~ : Expr, vis~ : Visibility, loc~ : 
Location, attrs~ : 
List[
Attribute], doc~ : DocString) -> Impl = _
  fn visit_Impl_TopImplRelation(Self, self_ty~ : Type, trait_~ : TypeName, quantifiers~ : 
List[TypeVarBinder], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, doc~ : DocString, is_declare~ : Bool) -> Impl = _
  fn visit_Impl_TopUsing(Self, pkg~ : Label, names~ : 
List[(AliasTarget, UsingKind)], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, doc~ : DocString) -> Impl = _
  fn visit_Impl_TopExtend(Self, type_name~ : TypeName, trait_~ : TypeName, names~ : 
List[AliasTarget], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, doc~ : DocString) -> Impl = _
  fn visit_Impl_TopImport(Self, kind~ : String?, packages~ : 
List[ImportPackage], loc~ : 
Location, doc~ : DocString) -> Impl = _
  fn visit_Expr(Self, Expr) -> Expr = _
  fn visit_Expr_Apply(Self, func~ : Expr, args~ : 
List[Argument], loc~ : 
Location) -> Expr = _
  fn visit_Expr_Infix(Self, op~ : Var, lhs~ : Expr, rhs~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Unary(Self, op~ : Var, expr~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Array(Self, exprs~ : 
List[Expr], is_iter~ : Bool, loc~ : 
Location) -> Expr = _
  fn visit_Expr_ArraySpread(Self, elems~ : 
List[SpreadableElem], is_iter~ : Bool, loc~ : 
Location) -> Expr = _
  fn visit_Expr_ArrayGet(Self, array~ : Expr, index~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_ArrayGetSlice(Self, array~ : Expr, start_index~ : Expr?, end_index~ : Expr?, index_loc~ : 
Location, loc~ : 
Location) -> Expr = _
  fn visit_Expr_ArraySet(Self, array~ : Expr, index~ : Expr, value~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_ArrayAugmentedSet(Self, op~ : Var, array~ : Expr, index~ : Expr, value~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Constant(Self, c~ : Constant, loc~ : 
Location) -> Expr = _
  fn visit_Expr_MultilineString(Self, elems~ : 
List[MultilineStringElem], loc~ : 
Location) -> Expr = _
  fn visit_Expr_Interp(Self, elems~ : 
List[InterpElem], loc~ : 
Location) -> Expr = _
  fn visit_Expr_BytesInterp(Self, elems~ : 
List[InterpElem], loc~ : 
Location) -> Expr = _
  fn visit_Expr_Constraint(Self, expr~ : Expr, ty~ : Type, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Constr(Self, constr~ : Constructor, loc~ : 
Location) -> Expr = _
  fn visit_Expr_LabelledBlock(Self, label~ : Label, body~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_While(Self, loop_cond~ : Expr, loop_body~ : Expr, while_else~ : Expr?, label~ : Label?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Function(Self, func~ : Func, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Ident(Self, id~ : Var, loc~ : 
Location) -> Expr = _
  fn visit_Expr_If(Self, cond~ : Expr, ifso~ : Expr, ifnot~ : Expr?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Guard(Self, cond~ : Expr, otherwise~ : Expr?, body~ : Expr, exclamation~ : Bool, guard_loc~ : 
Location, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Is(Self, expr~ : Expr, pat~ : Pattern, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Defer(Self, expr~ : Expr, body~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_LetFn(Self, name~ : Binder, func~ : Func, body~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_LetAnd(Self, bindings~ : 
List[(Binder, Type?, Func)], body~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Let(Self, pattern~ : Pattern, expr~ : Expr, body~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Sequence(Self, exprs~ : 
List[Expr], last_expr~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Tuple(Self, exprs~ : 
List[Expr], loc~ : 
Location) -> Expr = _
  fn visit_Expr_Record(Self, type_name~ : TypeName?, fields~ : 
List[FieldDef], trailing~ : TrailingMark, loc~ : 
Location) -> Expr = _
  fn visit_Expr_RecordUpdate(Self, type_name~ : TypeName?, record~ : Expr, fields~ : 
List[FieldDef], loc~ : 
Location) -> Expr = _
  fn visit_Expr_Field(Self, record~ : Expr, accessor~ : Accessor, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Method(Self, type_name~ : TypeName, method_name~ : Label, loc~ : 
Location) -> Expr = _
  fn visit_Expr_DotApply(Self, self~ : Expr, method_name~ : Label, args~ : 
List[Argument], return_self~ : Bool, loc~ : 
Location) -> Expr = _
  fn visit_Expr_As(Self, expr~ : Expr, trait_~ : TypeName, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Mutate(Self, record~ : Expr, accessor~ : Accessor, field~ : Expr, augmented_by~ : Var?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Match(Self, expr~ : Expr, cases~ : 
List[Case], match_loc~ : 
Location, loc~ : 
Location) -> Expr = _
  fn visit_Expr_LexMatch(Self, strategy~ : Label?, expr~ : Expr, match_loc~ : 
Location, cases~ : 
List[LexCase], loc~ : 
Location) -> Expr = _
  fn visit_Expr_LexScan(Self, strategy~ : Label?, expr~ : Expr, match_loc~ : 
Location, cases~ : 
List[LexScanCase], loc~ : 
Location) -> Expr = _
  fn visit_LexScanCase(Self, LexScanCase) -> LexScanCase = _
  fn visit_LexScanCasePattern(Self, LexScanCasePattern) -> LexScanCasePattern = _
  fn visit_LexScanCasePattern_Pattern(Self, RegexPattern) -> LexScanCasePattern = _
  fn visit_LexScanCasePattern_Binder(Self, Binder) -> LexScanCasePattern = _
  fn visit_LexScanCasePattern_Wildcard(Self, loc~ : 
Location) -> LexScanCasePattern = _
  fn visit_Expr_LetMut(Self, binder~ : Binder, ty~ : Type?, expr~ : Expr, body~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Pipe(Self, lhs~ : Expr, rhs~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Assign(Self, var_~ : Var, expr~ : Expr, augmented_by~ : Var?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Hole(Self, loc~ : 
Location, kind~ : Hole) -> Expr = _
  fn visit_Expr_Return(Self, return_value~ : Expr?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Raise(Self, err_value~ : Expr, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Unit(Self, loc~ : 
Location, faked~ : Bool) -> Expr = _
  fn visit_Expr_Break(Self, arg~ : Expr?, label~ : Label?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Continue(Self, args~ : 
List[Expr], label~ : Label?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_For(Self, binders~ : 
List[(Binder, Expr)], condition~ : Expr?, continue_block~ : 
List[(Binder, Expr)], body~ : Expr, for_else~ : Expr?, label~ : Label?, loc~ : 
Location, where_clause~ : WhereClause?) -> Expr = _
  fn visit_Expr_ForEach(Self, binders~ : 
List[Binder?], expr~ : Expr, init~ : 
List[(Binder, Expr)], continue_block~ : 
List[(Binder, Expr)], body~ : Expr, else_block~ : Expr?, where_clause~ : WhereClause?, label~ : Label?, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Try(Self, body~ : Expr, catch_~ : 
List[Case], try_else~ : 
List[Case]?, has_try~ : Bool, try_loc~ : 
Location, catch_loc~ : 
Location, else_loc~ : 
Location, loc~ : 
Location) -> Expr = _
  fn visit_Expr_TryOperator(Self, body~ : Expr, kind~ : TryOperatorKind, try_loc~ : 
Location, loc~ : 
Location) -> Expr = _
  fn visit_Expr_Map(Self, elems~ : 
List[MapExprElem], loc~ : 
Location) -> Expr = _
  fn visit_Expr_Group(Self, expr~ : Expr, group~ : Group, loc~ : 
Location) -> Expr = _
  fn visit_Expr_StaticAssert(Self, asserts~ : 
List[StaticAssertion], body~ : Expr) -> Expr = _
}

#
Accessor

source
pub(all) enum Accessor {
  Label(Label)
  Index(tuple_index~ : Int, loc~ : 
Location)
  Newtype(loc~ : 
Location)
} derive(
Debug)

#
AliasTarget

source
pub(all) struct AliasTarget {
  binder : Binder
  target : Label?
} derive(
Debug)

#
Argument

source
pub(all) struct Argument {
  value : Expr
  kind : ArgumentKind
} derive(
Debug)

#
ArgumentKind

source
pub(all) enum ArgumentKind {
  Positional
  Labelled(Label)
  LabelledPun(Label)
  LabelledOption(label~ : Label, question_loc~ : 
Location)
  LabelledOptionPun(label~ : Label, question_loc~ : 
Location)
} derive(
Debug)

#
ArrayPattern

source
pub(all) enum ArrayPattern {
  Pattern(Pattern)
  StringSpread(str~ : String, loc~ : 
Location)
  BytesSpread(bytes~ : String, loc~ : 
Location)
  ConstSpread(binder~ : Binder, pkg~ : String?, loc~ : 
Location)
} derive(
Debug)

#
ArrayPatterns

source

#
ArrowFnParam

source
pub(all) enum ArrowFnParam {
  Named(Binder)
  Unnamed(
Location)
} derive(
Debug)

Arrow function parameter type

#
Binder

source
pub(all) struct Binder {
  name : String
  loc : 
Location
} derive(
Debug)

#
Case

source
pub(all) struct Case {
  pattern : Pattern
  guard_ : Expr?
  body : Expr
} derive(
Debug)

#
Constant

source
pub(all) enum Constant {
  Bool(Bool)
  Byte(String)
  Bytes(String)
  Char(String)
  Int(String)
  Int64(String)
  UInt(String)
  UInt64(String)
  Float(String)
  Double(String)
  String(String)
  Regex(String)
  BigInt(String)
} derive(
Debug)

#
ConstrDecl

source

#
ConstrId

source

#
ConstrName

source
pub(all) struct ConstrName {
  name : String
  loc : 
Location
} derive(
Debug)

#
ConstrParam

source
pub(all) struct ConstrParam {
  ty : Type
  mut_ : Bool
  label : Label?
} derive(
Debug)

#
ConstrPatArg

source
pub(all) struct ConstrPatArg {
  pat : Pattern
  kind : ArgumentKind
} derive(
Debug)

#
Constructor

source

#
ConstructorExtraInfo

source
pub(all) enum ConstructorExtraInfo {
  TypeName(TypeName)
  TypeNameWithConstrPackage(type_name~ : TypeName, pkg~ : String)
  Package(String)
  NoExtraInfo
} derive(
Debug)

#
DeclBody

source
pub(all) enum DeclBody {
  DeclBody(expr~ : Expr)
  DeclStubs(FuncStubs)
  DeclNone
} derive(
Debug)

#
DerivingDirective

source

#
DocString

source

impl ToJson for DocString

#
DocString::empty

source
fn DocString::empty() -> DocString

#
DotDotBinder

source
pub(all) enum DotDotBinder {
  Underscore
  NoBinder
  BinderAs(Binder)
  Binder(Binder)
} derive(
Debug)

#
EmbeddedCode

source
pub(all) enum EmbeddedCode {
  CodeString(String)
  CodeMultilineString(
List[String])
} derive(
Debug)

#
ErrorType

source
pub(all) enum ErrorType {
  ErrorType(ty~ : Type)
  DefaultErrorType(loc~ : 
Location)
  NoErrorType
  Noraise(loc~ : 
Location)
  MaybeError(ty~ : Type)
} derive(
Debug)

#
ExceptionDecl

source
pub(all) enum ExceptionDecl {
  NoPayload
  EnumPayload(
List[ConstrDecl])
} derive(
Debug)

#
Expr

source
pub(all) enum Expr {
  Apply(func~ : Expr, args~ : 
List[Argument], loc~ : 
Location)
  Infix(op~ : Var, lhs~ : Expr, rhs~ : Expr, loc~ : 
Location)
  Unary(op~ : Var, expr~ : Expr, loc~ : 
Location)
  Array(exprs~ : 
List[Expr], is_iter~ : Bool, loc~ : 
Location)
  ArraySpread(elems~ : 
List[SpreadableElem], is_iter~ : Bool, loc~ : 
Location)
  ListComprehension(kind~ : ListComprehensionKind, guard_~ : Expr?, body~ : Expr, is_iter~ : Bool, loc~ : 
Location)
  ArrayGet(array~ : Expr, index~ : Expr, loc~ : 
Location)
  ArrayGetSlice(array~ : Expr, start_index~ : Expr?, end_index~ : Expr?, index_loc~ : 
Location, loc~ : 
Location)
  ArraySet(array~ : Expr, index~ : Expr, value~ : Expr, loc~ : 
Location)
  ArrayAugmentedSet(op~ : Var, array~ : Expr, index~ : Expr, value~ : Expr, loc~ : 
Location)
  Constant(c~ : Constant, loc~ : 
Location)
  MultilineString(elems~ : 
List[MultilineStringElem], loc~ : 
Location)
  Interp(elems~ : 
List[InterpElem], loc~ : 
Location)
  BytesInterp(elems~ : 
List[InterpElem], loc~ : 
Location)
  Constraint(expr~ : Expr, ty~ : Type, loc~ : 
Location)
  Constr(constr~ : Constructor, loc~ : 
Location)
  LabelledBlock(label~ : Label, body~ : Expr, loc~ : 
Location)
  While(loop_cond~ : Expr, loop_body~ : Expr, while_else~ : Expr?, label~ : Label?, loc~ : 
Location)
  Function(func~ : Func, loc~ : 
Location)
  Ident(id~ : Var, loc~ : 
Location)
  If(cond~ : Expr, ifso~ : Expr, ifnot~ : Expr?, loc~ : 
Location)
  Guard(cond~ : Expr, otherwise~ : Expr?, body~ : Expr, exclamation~ : Bool, guard_loc~ : 
Location, loc~ : 
Location)
  Is(expr~ : Expr, pat~ : Pattern, loc~ : 
Location)
  RegexMatch(expr~ : Expr, pat~ : RegexPattern, bindings~ : 
List[(Label, Binder?)], loc~ : 
Location)
  Defer(expr~ : Expr, body~ : Expr, loc~ : 
Location)
  LetFn(name~ : Binder, func~ : Func, body~ : Expr, loc~ : 
Location)
  LetAnd(bindings~ : 
List[(Binder, Type?, Func)], body~ : Expr, loc~ : 
Location)
  Let(pattern~ : Pattern, expr~ : Expr, body~ : Expr, loc~ : 
Location)
  Sequence(exprs~ : 
List[Expr], last_expr~ : Expr, loc~ : 
Location)
  Tuple(exprs~ : 
List[Expr], loc~ : 
Location)
  Record(type_name~ : TypeName?, fields~ : 
List[FieldDef], trailing~ : TrailingMark, loc~ : 
Location)
  RecordUpdate(type_name~ : TypeName?, record~ : Expr, fields~ : 
List[FieldDef], loc~ : 
Location)
  Field(record~ : Expr, accessor~ : Accessor, loc~ : 
Location)
  Method(type_name~ : TypeName, method_name~ : Label, loc~ : 
Location)
  DotApply(self~ : Expr, method_name~ : Label, args~ : 
List[Argument], return_self~ : Bool, loc~ : 
Location)
  As(expr~ : Expr, trait_~ : TypeName, loc~ : 
Location)
  Mutate(record~ : Expr, accessor~ : Accessor, field~ : Expr, augmented_by~ : Var?, loc~ : 
Location)
  Match(expr~ : Expr, cases~ : 
List[Case], match_loc~ : 
Location, loc~ : 
Location)
  LexMatch(strategy~ : Label?, expr~ : Expr, match_loc~ : 
Location, cases~ : 
List[LexCase], loc~ : 
Location)
  LexScan(strategy~ : Label?, expr~ : Expr, match_loc~ : 
Location, cases~ : 
List[LexScanCase], loc~ : 
Location)
  LetMut(binder~ : Binder, ty~ : Type?, expr~ : Expr, body~ : Expr, loc~ : 
Location)
  Pipe(lhs~ : Expr, rhs~ : Expr, loc~ : 
Location)
  RevPipe(lhs~ : Expr, rhs~ : Expr, loc~ : 
Location)
  Assign(var_~ : Var, expr~ : Expr, augmented_by~ : Var?, loc~ : 
Location)
  Hole(loc~ : 
Location, kind~ : Hole)
  Return(return_value~ : Expr?, loc~ : 
Location)
  Raise(err_value~ : Expr, loc~ : 
Location)
  Quantifier(kind~ : PredicateQuantifierKind, binder~ : Binder, binder_ty~ : Type, body~ : Expr, loc~ : 
Location)
  Implies(lhs~ : Expr, rhs~ : Expr, loc~ : 
Location)
  ProofAssert(expr~ : Expr, loc~ : 
Location)
  ProofLet(binder~ : Binder, expr~ : Expr, loc~ : 
Location)
  Unit(loc~ : 
Location, faked~ : Bool)
  Break(arg~ : Expr?, label~ : Label?, loc~ : 
Location)
  Continue(args~ : 
List[Expr], label~ : Label?, loc~ : 
Location)
  For(binders~ : 
List[(Binder, Expr)], condition~ : Expr?, continue_block~ : 
List[(Binder, Expr)], body~ : Expr, for_else~ : Expr?, where_clause~ : WhereClause?, label~ : Label?, loc~ : 
Location)
  ForEach(binders~ : 
List[Binder?], expr~ : Expr, init~ : 
List[(Binder, Expr)], continue_block~ : 
List[(Binder, Expr)], body~ : Expr, else_block~ : Expr?, where_clause~ : WhereClause?, label~ : Label?, loc~ : 
Location)
  Try(body~ : Expr, catch_~ : 
List[Case], try_else~ : 
List[Case]?, has_try~ : Bool, try_loc~ : 
Location, catch_loc~ : 
Location, else_loc~ : 
Location, loc~ : 
Location)
  TryOperator(body~ : Expr, kind~ : TryOperatorKind, try_loc~ : 
Location, loc~ : 
Location)
  Map(elems~ : 
List[MapExprElem], loc~ : 
Location)
  Group(expr~ : Expr, group~ : Group, loc~ : 
Location)
  TemplateWriting(expr~ : Expr, template~ : Expr, is_conditional~ : Bool, loc~ : 
Location)
  StaticAssert(asserts~ : 
List[StaticAssertion], body~ : Expr)
} derive(
Debug)

impl ToJson for Expr

#
Expr::json_repr

source
fn Expr::json_repr(self : Expr) -> Json

#
Expr::loc

source

#
FieldDecl

source

#
FieldDef

source
pub(all) struct FieldDef {
  label : Label
  expr : Expr
  is_pun : Bool
  loc : 
Location
} derive(
Debug)

#
FieldName

source
pub(all) struct FieldName {
  label : String
  loc : 
Location
} derive(
Debug)

#
FieldPat

source
pub(all) struct FieldPat {
  label : Label
  pattern : Pattern
  is_pun : Bool
  loc : 
Location
} derive(
Debug)

#
FnKind

source
pub(all) enum FnKind {
  Lambda
  Arrow
} derive(
Debug)

#
FunDecl

source

#
Func

source

#
FuncStubs

source
pub(all) enum FuncStubs {
  Import(module_name~ : String, func_name~ : String, language~ : String?)
  Embedded(language~ : String?, code~ : EmbeddedCode)
} derive(
Debug)

#
Group

source
pub(all) enum Group {
  Brace
  Paren
} derive(
Debug)

#
Hole

source
pub(all) enum Hole {
  Synthesized
  Incomplete
  Todo
} derive(
Debug)

#
Impl

source
pub(all) enum Impl {
  TopExpr(expr~ : Expr, is_main~ : Bool, is_async~ : 
Location?, loc~ : 
Location)
  TopTest(expr~ : Expr, name~ : (String, 
Location)?, params~ : 
List[Parameter]?, is_async~ : 
Location?, loc~ : 
Location, attrs~ : 
List[
Attribute], mut doc~ : DocString)
  TopTypeDef(TypeDecl)
  TopFuncDef(fun_decl~ : FunDecl, decl_body~ : DeclBody, where_clause~ : WhereClause?, loc~ : 
Location)
  TopLetDef(binder~ : Binder, ty~ : Type?, expr~ : Expr, vis~ : Visibility, is_constant~ : Bool, loc~ : 
Location, attrs~ : 
List[
Attribute], mut doc~ : DocString, is_declare~ : Bool)
  TopTrait(TraitDecl)
  TopImpl(self_ty~ : Type?, trait_~ : TypeName, method_name~ : Binder, quantifiers~ : 
List[TypeVarBinder], method_quantifiers~ : 
List[TypeVarBinder], params~ : 
List[Parameter], ret_ty~ : Type?, err_ty~ : ErrorType, body~ : DeclBody, vis~ : Visibility, loc~ : 
Location, attrs~ : 
List[
Attribute], mut doc~ : DocString)
  TopView(quantifiers~ : 
List[TypeVarBinder], source_ty~ : Type, view_type_name~ : String, view_type_loc~ : 
Location, view_constrs~ : 
List[ConstrDecl], view_func_name~ : Binder, parameters~ : 
List[Parameter], params_loc~ : 
Location, body~ : Expr, vis~ : Visibility, loc~ : 
Location, attrs~ : 
List[
Attribute], mut doc~ : DocString)
  TopImplRelation(self_ty~ : Type, trait_~ : TypeName, quantifiers~ : 
List[TypeVarBinder], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, mut doc~ : DocString, is_declare~ : Bool)
  TopUsing(pkg~ : Label, names~ : 
List[(AliasTarget, UsingKind)], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, mut doc~ : DocString)
  TopExtend(type_name~ : TypeName, trait_~ : TypeName, names~ : 
List[AliasTarget], vis~ : Visibility, attrs~ : 
List[
Attribute], loc~ : 
Location, mut doc~ : DocString)
  TopImport(kind~ : String?, packages~ : 
List[ImportPackage], loc~ : 
Location, mut doc~ : DocString)
} derive(
Debug)

impl ToJson for Impl

#
Impl::json_repr

source
fn Impl::json_repr(self : Impl) -> Json

#
Impl::loc

source

#
ImportPackage

source
pub(all) struct ImportPackage {
  path : String
  alias_ : String?
  loc : 
Location
} derive(
Debug)

#
InterpElem

source

#
IterVisitorBase

source
pub struct IterVisitorBase[T](T)

#
Label

source
pub(all) struct Label {
  name : String
  loc : 
Location
} derive(
Debug)

#
LexCase

source

#
LexPattern

source

#
LexScanCase

source
pub(all) struct LexScanCase {
  pat : LexScanCasePattern
  bindings : 
List[(Label, Binder?)]
  guard_ : Expr?
  body : Expr
} derive(
Debug)

#
LexScanCasePattern

source
pub(all) enum LexScanCasePattern {
  Pattern(RegexPattern)
  Binder(Binder)
  Wildcard(loc~ : 
Location)
} derive(
Debug)

#
LexTopPattern

source
pub(all) enum LexTopPattern {
  Pattern(LexPattern)
  Binder(Binder)
  Wildcard(loc~ : 
Location)
} derive(
Debug)

#
ListComprehensionKind

source
pub(all) enum ListComprehensionKind {
  Foreach(binders~ : 
List[Binder?], expr~ : Expr, init~ : 
List[(Binder, Expr)], continue_block~ : 
List[(Binder, Expr)])
  For(binders~ : 
List[(Binder, Expr)], condition~ : Expr?, continue_block~ : 
List[(Binder, Expr)], for_loc~ : 
Location)
} derive(
Debug)

#
LongIdent

source
pub(all) enum LongIdent {
  Ident(name~ : String)
  Dot(pkg~ : String, id~ : String)
} derive(
Debug)

#
LongIdent::dummy

source
fn LongIdent::dummy() -> LongIdent

The dummy LongIdent is used in typer to represent an parsing error.

#
MapExprElem

source

#
MapPatElem

source
pub(all) struct MapPatElem {
  key : Constant
  pat : Pattern
  match_absent : Bool
  key_loc : 
Location
  loc : 
Location
} derive(
Debug)

#
MapVisitorBase

source
pub(all) struct MapVisitorBase[T](T)

#
MultilineStringElem

source
pub(all) enum MultilineStringElem {
  String(String)
  Interp(
List[InterpElem])
} derive(
Debug)

#
Parameter

source
pub(all) enum Parameter {
  DiscardPositional(ty~ : Type?, loc~ : 
Location)
  Positional(binder~ : Binder, ty~ : Type?)
  Labelled(binder~ : Binder, ty~ : Type?)
  Optional(binder~ : Binder, default~ : Expr, ty~ : Type?)
  QuestionOptional(binder~ : Binder, ty~ : Type?)
} derive(
Debug)

#
Pattern

source
pub(all) enum Pattern {
  Alias(pat~ : Pattern, alias_~ : Binder, loc~ : 
Location)
  Any(loc~ : 
Location)
  Array(pats~ : ArrayPatterns, loc~ : 
Location)
  Constant(c~ : Constant, loc~ : 
Location)
  Constraint(pat~ : Pattern, ty~ : Type, loc~ : 
Location)
  Constr(constr~ : Constructor, args~ : 
List[ConstrPatArg]?, is_open~ : Bool, loc~ : 
Location)
  Or(pat1~ : Pattern, pat2~ : Pattern, loc~ : 
Location)
  Tuple(pats~ : 
List[Pattern], loc~ : 
Location)
  Var(Binder)
  Record(fields~ : 
List[FieldPat], is_closed~ : Bool, loc~ : 
Location)
  Map(elems~ : 
List[MapPatElem], is_closed~ : Bool, loc~ : 
Location)
  Range(lhs~ : Pattern, rhs~ : Pattern, kind~ : RangeKind, loc~ : 
Location)
  With(pat~ : Pattern, bindings~ : 
List[(Binder, Expr)], loc~ : 
Location)
  SpecialConstr(binder~ : Binder, args~ : 
List[ConstrPatArg], loc~ : 
Location)
} derive(
Debug)

#
PredicateQuantifierKind

source
pub(all) enum PredicateQuantifierKind {
  Forall
  Exists
} derive(
Debug)

#
RangeKind

source
pub(all) enum RangeKind {
  Inclusive
  Exclusive
  InclusiveMissingEqual
} derive(
Debug)

#
RegexPattern

source
pub(all) enum RegexPattern {
  Literal(lit~ : String, loc~ : 
Location)
  Reference(lid~ : LongIdent, loc~ : 
Location)
  Sequence(pat1~ : RegexPattern, pat2~ : RegexPattern, loc~ : 
Location)
  Alternation(pat1~ : RegexPattern, pat2~ : RegexPattern, loc~ : 
Location)
  Alias(pat~ : RegexPattern, binder~ : Binder, loc~ : 
Location)
} derive(
Debug)

#
SpreadableElem

source
pub(all) enum SpreadableElem {
  Regular(Expr)
  Spread(expr~ : Expr, loc~ : 
Location)
} derive(
Debug)

#
StaticAssertion

source
pub(all) struct StaticAssertion {
  ty : Type
  trait_ : LongIdent
  loc : 
Location
  msg : String
} derive(
Debug)

#
TrailingMark

source
pub(all) enum TrailingMark {
  Comma
  Semi
  None
} derive(
Debug)

#
TraitDecl

source

#
TraitMethodDecl

source

#
TryOperatorKind

source
pub(all) enum TryOperatorKind {
  Exclamation
} derive(
Debug)

#
Type

source

#
TypeDecl

source

#
TypeDeclBinder

source
pub(all) struct TypeDeclBinder {
  name : String?
  loc : 
Location
} derive(
Debug)

#
TypeDesc

source

#
TypeName

source
pub(all) struct TypeName {
  name : LongIdent
  is_object : Bool
  loc : 
Location
} derive(
Debug)

#
TypeVarBinder

source
pub(all) struct TypeVarBinder {
  name : String
  name_loc : 
Location
  constraints : 
List[TypeVarConstraint]
} derive(
Debug)

Represent type variable and optional constraints.

fn [T] f() -> Unit {...}
 // ^---- TypeVarBinder
fn [T : TraitA + TraitB] f() -> Unit {...}
 // ^^^^^^^^^^^^^^^^^^^----- TypeVarBinder

#
TypeVarConstraint

source
pub(all) struct TypeVarConstraint {
  trait_ : LongIdent
  loc : 
Location
} derive(
Debug)

#
UsingKind

source
pub(all) enum UsingKind {
  Value
  Type
  Trait
} derive(
Debug)

#
Var

source

#
Visibility

source
pub(all) enum Visibility {
  Default
  Pub(attr~ : String?, loc~ : 
Location)
  Priv(loc~ : 
Location)
} derive(
Debug)

#
WhereClause

source

#
arrow_fn_param_to_expr

source
fn arrow_fn_param_to_expr(p : ArrowFnParam) -> Expr

Convert arrow function parameter to expression

#
binder_to_expr

source
fn binder_to_expr(p : Binder) -> Expr

Convert binder to expression

#
bracket_loc

source

#
desugar_array_augmented_set

source
fn desugar_array_augmented_set(loc : 
Location, op : Var, array : Expr, index : Expr, value : Expr) -> Expr

Desugar augmented array assignment

#
desugar_array_get

source
fn desugar_array_get(loc~ : 
Location, obj : Expr, index : Expr) -> Expr

Desugar array get operation to method call

#
desugar_array_set

source
fn desugar_array_set(loc~ : 
Location, obj : Expr, index : Expr, value : Expr) -> Expr

Desugar array set operation to method call

#
label_to_expr

source
fn label_to_expr(loc~ : 
Location, label : Label) -> Expr

Convert label to expression

#
label_to_pat

source
fn label_to_pat(loc~ : 
Location, label : Label) -> Pattern

Convert label to pattern

#
loc_of_expression

source
fn loc_of_expression(expr : Expr) -> 
Location

#
make_alias_pattern

source
fn make_alias_pattern(loc~ : 
Location, pat : Pattern, alias_ : Binder) -> Pattern

Create alias pattern

#
make_array_expr

source
fn make_array_expr(loc~ : 
Location, is_iter~ : Bool, elems : 
List[SpreadableElem]) -> Expr

Create array expression with possible spread elements

#
make_arrow_fn

source

Create arrow function

#
make_assign_opt

source
fn make_assign_opt(loc~ : 
Location, lhs : Expr, rhs : Expr) -> Expr?

Try to create assignment expression

#
make_augmented_assign_opt

source
fn make_augmented_assign_opt(loc~ : 
Location, op : Var, lhs : Expr, rhs : Expr) -> Expr?

Try to create augmented assignment expression

#
make_bytes_interp_expr

source

#
make_constant_expr

source
fn make_constant_expr(loc~ : 
Location, c : Constant) -> Expr

Create constant expression with location

#
make_constant_pattern

source
fn make_constant_pattern(loc~ : 
Location, c : Constant) -> Pattern

Create constant pattern

#
make_constr_pattern

source
fn make_constr_pattern(loc~ : 
Location, constr : Constructor, args : 
List[ConstrPatArg]?, is_open : Bool) -> Pattern

Create constructor pattern

#
make_double

source
fn make_double(f : String) -> Constant

Create double constant

#
make_field_def

source
fn make_field_def(loc~ : 
Location, label : Label, expr : Expr, is_pun : Bool) -> FieldDef

Create field definition

#
make_field_pat

source
fn make_field_pat(loc~ : 
Location, label : Label, pattern : Pattern, is_pun : Bool) -> FieldPat

Create field pattern

#
make_float

source
fn make_float(f : String) -> Constant

Create float constant

#
make_ident_expr

source
fn make_ident_expr(loc~ : 
Location, id : Var) -> Expr

Create identifier expression

#
make_int

source
fn make_int(i : String) -> Constant

Parse integer literal with suffix

#
make_interp_expr

source

Create interpolation expression

#
make_interps

source

Create interpolation elements from literal components

#
make_option_type

source

Create option type

#
make_record_expr

source
fn make_record_expr(loc~ : 
Location, trailing~ : TrailingMark, type_name : TypeName?, fields : 
List[FieldDef]) -> Expr

Create record expression

#
make_tuple_expr

source

Create tuple expression

#
make_tuple_pattern

source

Create tuple pattern

#
make_tuple_type

source

Create tuple type

#
make_uminus

source
fn make_uminus(loc~ : 
Location, name : String, arg : Expr) -> Expr

Create unary minus expression

#
make_unot

source
fn make_unot(loc~ : 
Location, arg : Expr) -> Expr

Create logical not expression

#
make_uplus

source
fn make_uplus(loc~ : 
Location, name : String, arg : Expr) -> Expr

Create unary plus expression

#
no_location

source

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io