🥮 mooncakes.io

    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    ?, nocancel_~ : 
    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_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_ConstrAny(Self, type_name~ : TypeName, 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, nocancel_~ : 
    Location    ?, 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_ErrDefer(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_LexScan(Self, streaming~ : Bool, 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    ?, nocancel_~ : 
    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_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_ConstrAny(Self, type_name~ : TypeName, 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, nocancel_~ : 
    Location    ?, 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_ErrDefer(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_LexScan(Self, streaming~ : Bool, 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    )
      ErrDefer(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    )
      LexScan(streaming~ : Bool, 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, nocancel_~ : 
    Location    ?, 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    )

    LexScanCase

    source

    LexScanCasePattern

    source
    pub(all) enum LexScanCasePattern {
      Pattern(RegexPattern)
      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    )
      ConstrAny(type_name~ : TypeName, 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, recovered_~ : Bool, 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