Function foldAstStateful

Parameters

• ast: RNode<Info>
• down: Down
• folds: {
      down: DownFold<Info, Down>;
      foldAccess: ((node: RAccess<Info>, name: Up, access: readonly ("<>" | Up)[], down: Down) => Up);
      foldBinaryOp: ((op: RBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up);
      foldExprList: ((exprList: RExpressionList<Info>, grouping: undefined | [start: Up, end: Up], expressions: Up[], down: Down) => Up);
      foldIfThenElse: ((ifThenExpr: RIfThenElse<Info>, cond: Up, then: Up, otherwise: undefined | Up, down: Down) => Up);
      foldLogical: ((logical: RLogical<Info>, down: Down) => Up);
      foldNumber: ((num: RNumber<Info>, down: Down) => Up);
      foldPipe: ((op: RPipe<Info>, lhs: Up, rhs: Up, down: Down) => Up);
      foldString: ((str: RString<Info>, down: Down) => Up);
      foldSymbol: ((symbol: RSymbol<Info, string>, down: Down) => Up);
      foldUnaryOp: ((op: RUnaryOp<Info>, operand: Up, down: Down) => Up);
      functions: {
          foldArgument: ((argument: RArgument<Info>, name: undefined | Up, value: undefined | Up, down: Down) => Up);
          foldFunctionCall: ((call: RFunctionCall<Info>, functionNameOrExpression: Up, args: ("<>" | Up)[], down: Down) => Up);
          foldFunctionDefinition: ((definition: RFunctionDefinition<Info>, params: Up[], body: Up, down: Down) => Up);
          foldParameter: ((parameter: RParameter<Info>, name: Up, defaultValue: undefined | Up, down: Down) => Up);
      };
      loop: {
          foldBreak: ((next: RBreak<Info>, down: Down) => Up);
          foldFor: ((loop: RForLoop<Info>, variable: Up, vector: Up, body: Up, down: Down) => Up);
          foldNext: ((next: RNext<Info>, down: Down) => Up);
          foldRepeat: ((loop: RRepeatLoop<Info>, body: Up, down: Down) => Up);
          foldWhile: ((loop: RWhileLoop<Info>, condition: Up, body: Up, down: Down) => Up);
      };
      other: {
          foldComment: ((comment: RComment<Info>, down: Down) => Up);
          foldLineDirective: ((comment: RLineDirective<Info>, down: Down) => Up);
      };
  }

  • Readonlydown: DownFold<Info, Down>

  • ReadonlyfoldAccess: ((node: RAccess<Info>, name: Up, access: readonly ("<>" | Up)[], down: Down) => Up)

    • • (node, name, access, down): Up

      • Parameters

        • node: RAccess<Info>
        • name: Up
        • access: readonly ("<>" | Up)[]
        • down: Down

        Returns Up

  • ReadonlyfoldBinaryOp: ((op: RBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up)

    • • (op, lhs, rhs, down): Up

      • Parameters

        • op: RBinaryOp<Info>
        • lhs: Up
        • rhs: Up
        • down: Down

        Returns Up

  • ReadonlyfoldExprList: ((exprList: RExpressionList<Info>, grouping: undefined | [start: Up, end: Up], expressions: Up[], down: Down) => Up)

    • • (exprList, grouping, expressions, down): Up

      • Parameters

        • exprList: RExpressionList<Info>
        • grouping: undefined | [start: Up, end: Up]
        • expressions: Up[]
        • down: Down

        Returns Up

  • ReadonlyfoldIfThenElse: ((ifThenExpr: RIfThenElse<Info>, cond: Up, then: Up, otherwise: undefined | Up, down: Down) => Up)

    The otherwise argument is undefined if the else branch is missing

    • • (ifThenExpr, cond, then, otherwise, down): Up

      • Parameters

        • ifThenExpr: RIfThenElse<Info>
        • cond: Up
        • then: Up
        • otherwise: undefined | Up
        • down: Down

        Returns Up

  • ReadonlyfoldLogical: ((logical: RLogical<Info>, down: Down) => Up)

    • • (logical, down): Up

      • Parameters

        • logical: RLogical<Info>
        • down: Down

        Returns Up

  • ReadonlyfoldNumber: ((num: RNumber<Info>, down: Down) => Up)

    • • (num, down): Up

      • Parameters

        • num: RNumber<Info>
        • down: Down

        Returns Up

  • ReadonlyfoldPipe: ((op: RPipe<Info>, lhs: Up, rhs: Up, down: Down) => Up)

    • • (op, lhs, rhs, down): Up

      • Parameters

        • op: RPipe<Info>
        • lhs: Up
        • rhs: Up
        • down: Down

        Returns Up

  • ReadonlyfoldString: ((str: RString<Info>, down: Down) => Up)

    • • (str, down): Up

      • Parameters

        • str: RString<Info>
        • down: Down

        Returns Up

  • ReadonlyfoldSymbol: ((symbol: RSymbol<Info, string>, down: Down) => Up)

    • • (symbol, down): Up

      • Parameters

        • symbol: RSymbol<Info, string>
        • down: Down

        Returns Up

  • ReadonlyfoldUnaryOp: ((op: RUnaryOp<Info>, operand: Up, down: Down) => Up)

    • • (op, operand, down): Up

      • Parameters

        • op: RUnaryOp<Info>
        • operand: Up
        • down: Down

        Returns Up

  • Readonlyfunctions: {
        foldArgument: ((argument: RArgument<Info>, name: undefined | Up, value: undefined | Up, down: Down) => Up);
        foldFunctionCall: ((call: RFunctionCall<Info>, functionNameOrExpression: Up, args: ("<>" | Up)[], down: Down) => Up);
        foldFunctionDefinition: ((definition: RFunctionDefinition<Info>, params: Up[], body: Up, down: Down) => Up);
        foldParameter: ((parameter: RParameter<Info>, name: Up, defaultValue: undefined | Up, down: Down) => Up);
    }

    • ReadonlyfoldArgument: ((argument: RArgument<Info>, name: undefined | Up, value: undefined | Up, down: Down) => Up)

      The name is undefined if the argument is unnamed, the value, if we have something like x=,...

      • • (argument, name, value, down): Up

        • Parameters

          • argument: RArgument<Info>
          • name: undefined | Up
          • value: undefined | Up
          • down: Down

          Returns Up

    • ReadonlyfoldFunctionCall: ((call: RFunctionCall<Info>, functionNameOrExpression: Up, args: ("<>" | Up)[], down: Down) => Up)

      folds named and unnamed function calls

      • • (call, functionNameOrExpression, args, down): Up

        • Parameters

          • call: RFunctionCall<Info>
          • functionNameOrExpression: Up
          • args: ("<>" | Up)[]
          • down: Down

          Returns Up

    • ReadonlyfoldFunctionDefinition: ((definition: RFunctionDefinition<Info>, params: Up[], body: Up, down: Down) => Up)

      • • (definition, params, body, down): Up

        • Parameters

          • definition: RFunctionDefinition<Info>
          • params: Up[]
          • body: Up
          • down: Down

          Returns Up

    • ReadonlyfoldParameter: ((parameter: RParameter<Info>, name: Up, defaultValue: undefined | Up, down: Down) => Up)

      The defaultValue is undefined if the argument was not initialized with a default value

      • • (parameter, name, defaultValue, down): Up

        • Parameters

          • parameter: RParameter<Info>
          • name: Up
          • defaultValue: undefined | Up
          • down: Down

          Returns Up

  • Readonlyloop: {
        foldBreak: ((next: RBreak<Info>, down: Down) => Up);
        foldFor: ((loop: RForLoop<Info>, variable: Up, vector: Up, body: Up, down: Down) => Up);
        foldNext: ((next: RNext<Info>, down: Down) => Up);
        foldRepeat: ((loop: RRepeatLoop<Info>, body: Up, down: Down) => Up);
        foldWhile: ((loop: RWhileLoop<Info>, condition: Up, body: Up, down: Down) => Up);
    }

    • ReadonlyfoldBreak: ((next: RBreak<Info>, down: Down) => Up)

      • • (next, down): Up

        • Parameters

          • next: RBreak<Info>
          • down: Down

          Returns Up

    • ReadonlyfoldFor: ((loop: RForLoop<Info>, variable: Up, vector: Up, body: Up, down: Down) => Up)

      • • (loop, variable, vector, body, down): Up

        • Parameters

          • loop: RForLoop<Info>
          • variable: Up
          • vector: Up
          • body: Up
          • down: Down

          Returns Up

    • ReadonlyfoldNext: ((next: RNext<Info>, down: Down) => Up)

      • • (next, down): Up

        • Parameters

          • next: RNext<Info>
          • down: Down

          Returns Up

    • ReadonlyfoldRepeat: ((loop: RRepeatLoop<Info>, body: Up, down: Down) => Up)

      • • (loop, body, down): Up

        • Parameters

          • loop: RRepeatLoop<Info>
          • body: Up
          • down: Down

          Returns Up

    • ReadonlyfoldWhile: ((loop: RWhileLoop<Info>, condition: Up, body: Up, down: Down) => Up)

      • • (loop, condition, body, down): Up

        • Parameters

          • loop: RWhileLoop<Info>
          • condition: Up
          • body: Up
          • down: Down

          Returns Up

  • Readonlyother: {
        foldComment: ((comment: RComment<Info>, down: Down) => Up);
        foldLineDirective: ((comment: RLineDirective<Info>, down: Down) => Up);
    }

    • ReadonlyfoldComment: ((comment: RComment<Info>, down: Down) => Up)

      • • (comment, down): Up

        • Parameters

          • comment: RComment<Info>
          • down: Down

          Returns Up

    • ReadonlyfoldLineDirective: ((comment: RLineDirective<Info>, down: Down) => Up)

      • • (comment, down): Up

        • Parameters

          • comment: RLineDirective<Info>
          • down: Down

          Returns Up