Function foldAst

Parameters

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

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

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

      • Parameters

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

        Returns T

  • ReadonlyfoldBinaryOp: ((op: RBinaryOp<Info>, lhs: T, rhs: T, down: undefined) => T)

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

      • Parameters

        • op: RBinaryOp<Info>
        • lhs: T
        • rhs: T
        • down: undefined

        Returns T

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

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

      • Parameters

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

        Returns T

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

    The otherwise argument is undefined if the else branch is missing

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

      • Parameters

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

        Returns T

  • ReadonlyfoldLogical: ((logical: RLogical<Info>, down: undefined) => T)

    • • (logical, down): T

      • Parameters

        • logical: RLogical<Info>
        • down: undefined

        Returns T

  • ReadonlyfoldNumber: ((num: RNumber<Info>, down: undefined) => T)

    • • (num, down): T

      • Parameters

        • num: RNumber<Info>
        • down: undefined

        Returns T

  • ReadonlyfoldPipe: ((op: RPipe<Info>, lhs: T, rhs: T, down: undefined) => T)

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

      • Parameters

        • op: RPipe<Info>
        • lhs: T
        • rhs: T
        • down: undefined

        Returns T

  • ReadonlyfoldString: ((str: RString<Info>, down: undefined) => T)

    • • (str, down): T

      • Parameters

        • str: RString<Info>
        • down: undefined

        Returns T

  • ReadonlyfoldSymbol: ((symbol: RSymbol<Info, string>, down: undefined) => T)

    • • (symbol, down): T

      • Parameters

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

        Returns T

  • ReadonlyfoldUnaryOp: ((op: RUnaryOp<Info>, operand: T, down: undefined) => T)

    • • (op, operand, down): T

      • Parameters

        • op: RUnaryOp<Info>
        • operand: T
        • down: undefined

        Returns T

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

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

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

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

        • Parameters

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

          Returns T

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

      folds named and unnamed function calls

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

        • Parameters

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

          Returns T

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

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

        • Parameters

          • definition: RFunctionDefinition<Info>
          • params: T[]
          • body: T
          • down: undefined

          Returns T

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

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

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

        • Parameters

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

          Returns T

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

    • ReadonlyfoldBreak: ((next: RBreak<Info>, down: undefined) => T)

      • • (next, down): T

        • Parameters

          • next: RBreak<Info>
          • down: undefined

          Returns T

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

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

        • Parameters

          • loop: RForLoop<Info>
          • variable: T
          • vector: T
          • body: T
          • down: undefined

          Returns T

    • ReadonlyfoldNext: ((next: RNext<Info>, down: undefined) => T)

      • • (next, down): T

        • Parameters

          • next: RNext<Info>
          • down: undefined

          Returns T

    • ReadonlyfoldRepeat: ((loop: RRepeatLoop<Info>, body: T, down: undefined) => T)

      • • (loop, body, down): T

        • Parameters

          • loop: RRepeatLoop<Info>
          • body: T
          • down: undefined

          Returns T

    • ReadonlyfoldWhile: ((loop: RWhileLoop<Info>, condition: T, body: T, down: undefined) => T)

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

        • Parameters

          • loop: RWhileLoop<Info>
          • condition: T
          • body: T
          • down: undefined

          Returns T

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

    • ReadonlyfoldComment: ((comment: RComment<Info>, down: undefined) => T)

      • • (comment, down): T

        • Parameters

          • comment: RComment<Info>
          • down: undefined

          Returns T

    • ReadonlyfoldLineDirective: ((comment: RLineDirective<Info>, down: undefined) => T)

      • • (comment, down): T

        • Parameters

          • comment: RLineDirective<Info>
          • down: undefined

          Returns T