Method Visit

optimizer/sum_range.go:9–68

(node *Node)

type sumRange struct{}

func (*sumRange) Visit(node *Node) {
	// Pattern 1: sum(m..n) or sum(m..n, predicate) where m and n are constant integers
	if sumBuiltin, ok := (*node).(*BuiltinNode); ok &&
		sumBuiltin.Name == "sum" &&
		(len(sumBuiltin.Arguments) == 1 || len(sumBuiltin.Arguments) == 2) {
		if rangeOp, ok := sumBuiltin.Arguments[0].(*BinaryNode); ok && rangeOp.Operator == ".." {
			if from, ok := rangeOp.Left.(*IntegerNode); ok {
				if to, ok := rangeOp.Right.(*IntegerNode); ok {
					m := from.Value
					n := to.Value
					if n >= m {
						count := n - m + 1
						// Use the arithmetic series formula: (n - m + 1) * (m + n) / 2
						sum := count * (m + n) / 2

						if len(sumBuiltin.Arguments) == 1 {
							// sum(m..n)
							patchWithType(node, &IntegerNode{Value: sum})
						} else if len(sumBuiltin.Arguments) == 2 {
							// sum(m..n, predicate)
							if result, ok := applySumPredicate(sum, count, sumBuiltin.Arguments[1]); ok {
								patchWithType(node, &IntegerNode{Value: result})
							}
						}
					}
				}
			}
		}
	}

	// Pattern 2: reduce(m..n, # + #acc) where m and n are constant integers
	if reduceBuiltin, ok := (*node).(*BuiltinNode); ok &&
		reduceBuiltin.Name == "reduce" &&
		(len(reduceBuiltin.Arguments) == 2 || len(reduceBuiltin.Arguments) == 3) {
		if rangeOp, ok := reduceBuiltin.Arguments[0].(*BinaryNode); ok && rangeOp.Operator == ".." {
			if from, ok := rangeOp.Left.(*IntegerNode); ok {
				if to, ok := rangeOp.Right.(*IntegerNode); ok {
					if isPointerPlusAcc(reduceBuiltin.Arguments[1]) {
						m := from.Value
						n := to.Value
						if n >= m {
							// Use the arithmetic series formula: (n - m + 1) * (m + n) / 2
							sum := (n - m + 1) * (m + n) / 2

							// Check for optional initialValue (3rd argument)
							if len(reduceBuiltin.Arguments) == 3 {
								if initialValue, ok := reduceBuiltin.Arguments[2].(*IntegerNode); ok {
									result := initialValue.Value + sum
									patchWithType(node, &IntegerNode{Value: result})
								}
							} else {
								patchWithType(node, &IntegerNode{Value: sum})
							}
						}
					}
				}
			}
		}