Skip to content

Commit 423011b

Browse files
mgomesmgomes
committed
split arithmetic operators from value helpers
1 parent 2ee1842 commit 423011b

3 files changed

Lines changed: 238 additions & 232 deletions

File tree

‎docs/architecture.md‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,8 @@ Key files:
4545
- `vibes/execution_members_array_transforms.go` (array mutation/transform member methods)
4646
- `vibes/execution_members_array_grouping.go` (array sort/group/tally member methods)
4747
- `vibes/execution_types.go` (type-checking + type formatting helpers)
48-
- `vibes/execution_values.go` (value conversion, arithmetic, comparison helpers)
48+
- `vibes/execution_values.go` (value conversion, sorting, and flattening helpers)
49+
- `vibes/execution_values_arithmetic.go` (value arithmetic and comparison operators)
4950

5051
## Parsing And AST
5152

‎vibes/execution_values.go‎

Lines changed: 0 additions & 231 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,8 @@
11
package vibes
22

33
import (
4-
"errors"
54
"fmt"
65
"math"
7-
"slices"
8-
"time"
96
)
107

118
func valueToHashKey(val Value) (string, error) {
@@ -180,231 +177,3 @@ func floatToInt64Checked(v float64, method string) (int64, error) {
180177
}
181178
return int64(v), nil
182179
}
183-
184-
func addValues(left, right Value) (Value, error) {
185-
switch {
186-
case left.Kind() == KindInt && right.Kind() == KindInt:
187-
return NewInt(left.Int() + right.Int()), nil
188-
case (left.Kind() == KindInt || left.Kind() == KindFloat) && (right.Kind() == KindInt || right.Kind() == KindFloat):
189-
return NewFloat(left.Float() + right.Float()), nil
190-
case left.Kind() == KindTime && right.Kind() == KindDuration:
191-
return NewTime(left.Time().Add(time.Duration(right.Duration().Seconds()) * time.Second)), nil
192-
case right.Kind() == KindTime && left.Kind() == KindDuration:
193-
return NewTime(right.Time().Add(time.Duration(left.Duration().Seconds()) * time.Second)), nil
194-
case left.Kind() == KindDuration && right.Kind() == KindDuration:
195-
return NewDuration(Duration{seconds: left.Duration().Seconds() + right.Duration().Seconds()}), nil
196-
case left.Kind() == KindDuration && (right.Kind() == KindInt || right.Kind() == KindFloat):
197-
secs, err := valueToInt64(right)
198-
if err != nil {
199-
return NewNil(), fmt.Errorf("unsupported addition operands")
200-
}
201-
return NewDuration(Duration{seconds: left.Duration().Seconds() + secs}), nil
202-
case right.Kind() == KindDuration && (left.Kind() == KindInt || left.Kind() == KindFloat):
203-
secs, err := valueToInt64(left)
204-
if err != nil {
205-
return NewNil(), fmt.Errorf("unsupported addition operands")
206-
}
207-
return NewDuration(Duration{seconds: right.Duration().Seconds() + secs}), nil
208-
case left.Kind() == KindArray && right.Kind() == KindArray:
209-
lArr := left.Array()
210-
rArr := right.Array()
211-
out := make([]Value, len(lArr)+len(rArr))
212-
copy(out, lArr)
213-
copy(out[len(lArr):], rArr)
214-
return NewArray(out), nil
215-
case left.Kind() == KindString || right.Kind() == KindString:
216-
return NewString(left.String() + right.String()), nil
217-
case left.Kind() == KindMoney && right.Kind() == KindMoney:
218-
sum, err := left.Money().add(right.Money())
219-
if err != nil {
220-
return NewNil(), err
221-
}
222-
return NewMoney(sum), nil
223-
default:
224-
return NewNil(), fmt.Errorf("unsupported addition operands")
225-
}
226-
}
227-
228-
func subtractValues(left, right Value) (Value, error) {
229-
switch {
230-
case left.Kind() == KindInt && right.Kind() == KindInt:
231-
return NewInt(left.Int() - right.Int()), nil
232-
case (left.Kind() == KindInt || left.Kind() == KindFloat) && (right.Kind() == KindInt || right.Kind() == KindFloat):
233-
return NewFloat(left.Float() - right.Float()), nil
234-
case left.Kind() == KindTime && right.Kind() == KindDuration:
235-
return NewTime(left.Time().Add(-time.Duration(right.Duration().Seconds()) * time.Second)), nil
236-
case left.Kind() == KindTime && right.Kind() == KindTime:
237-
diff := left.Time().Sub(right.Time())
238-
return NewDuration(Duration{seconds: int64(diff / time.Second)}), nil
239-
case left.Kind() == KindDuration && right.Kind() == KindDuration:
240-
return NewDuration(Duration{seconds: left.Duration().Seconds() - right.Duration().Seconds()}), nil
241-
case left.Kind() == KindDuration && (right.Kind() == KindInt || right.Kind() == KindFloat):
242-
secs, err := valueToInt64(right)
243-
if err != nil {
244-
return NewNil(), fmt.Errorf("unsupported subtraction operands")
245-
}
246-
return NewDuration(Duration{seconds: left.Duration().Seconds() - secs}), nil
247-
case left.Kind() == KindArray && right.Kind() == KindArray:
248-
lArr := left.Array()
249-
rArr := right.Array()
250-
out := make([]Value, 0, len(lArr))
251-
for _, item := range lArr {
252-
found := slices.ContainsFunc(rArr, item.Equal)
253-
if !found {
254-
out = append(out, item)
255-
}
256-
}
257-
return NewArray(out), nil
258-
case left.Kind() == KindMoney && right.Kind() == KindMoney:
259-
diff, err := left.Money().sub(right.Money())
260-
if err != nil {
261-
return NewNil(), err
262-
}
263-
return NewMoney(diff), nil
264-
default:
265-
return NewNil(), fmt.Errorf("unsupported subtraction operands")
266-
}
267-
}
268-
269-
func multiplyValues(left, right Value) (Value, error) {
270-
switch {
271-
case left.Kind() == KindInt && right.Kind() == KindInt:
272-
return NewInt(left.Int() * right.Int()), nil
273-
case (left.Kind() == KindInt || left.Kind() == KindFloat) && (right.Kind() == KindInt || right.Kind() == KindFloat):
274-
return NewFloat(left.Float() * right.Float()), nil
275-
case left.Kind() == KindDuration && (right.Kind() == KindInt || right.Kind() == KindFloat):
276-
secs, err := valueToInt64(right)
277-
if err != nil {
278-
return NewNil(), fmt.Errorf("unsupported multiplication operands")
279-
}
280-
return NewDuration(Duration{seconds: left.Duration().Seconds() * secs}), nil
281-
case right.Kind() == KindDuration && (left.Kind() == KindInt || left.Kind() == KindFloat):
282-
secs, err := valueToInt64(left)
283-
if err != nil {
284-
return NewNil(), fmt.Errorf("unsupported multiplication operands")
285-
}
286-
return NewDuration(Duration{seconds: right.Duration().Seconds() * secs}), nil
287-
case left.Kind() == KindMoney && right.Kind() == KindInt:
288-
return NewMoney(left.Money().mulInt(right.Int())), nil
289-
case left.Kind() == KindInt && right.Kind() == KindMoney:
290-
return NewMoney(right.Money().mulInt(left.Int())), nil
291-
default:
292-
return NewNil(), fmt.Errorf("unsupported multiplication operands")
293-
}
294-
}
295-
296-
func divideValues(left, right Value) (Value, error) {
297-
switch {
298-
case (left.Kind() == KindInt || left.Kind() == KindFloat) && (right.Kind() == KindInt || right.Kind() == KindFloat):
299-
if right.Float() == 0 {
300-
return NewNil(), errors.New("division by zero")
301-
}
302-
return NewFloat(left.Float() / right.Float()), nil
303-
case left.Kind() == KindDuration && right.Kind() == KindDuration:
304-
if right.Duration().Seconds() == 0 {
305-
return NewNil(), errors.New("division by zero")
306-
}
307-
return NewFloat(float64(left.Duration().Seconds()) / float64(right.Duration().Seconds())), nil
308-
case left.Kind() == KindDuration && (right.Kind() == KindInt || right.Kind() == KindFloat):
309-
secs, err := valueToInt64(right)
310-
if err != nil {
311-
return NewNil(), fmt.Errorf("unsupported division operands")
312-
}
313-
if secs == 0 {
314-
return NewNil(), errors.New("division by zero")
315-
}
316-
return NewDuration(Duration{seconds: left.Duration().Seconds() / secs}), nil
317-
case left.Kind() == KindMoney && right.Kind() == KindInt:
318-
res, err := left.Money().divInt(right.Int())
319-
if err != nil {
320-
return NewNil(), err
321-
}
322-
return NewMoney(res), nil
323-
default:
324-
return NewNil(), fmt.Errorf("unsupported division operands")
325-
}
326-
}
327-
328-
func moduloValues(left, right Value) (Value, error) {
329-
if left.Kind() == KindInt && right.Kind() == KindInt {
330-
if right.Int() == 0 {
331-
return NewNil(), errors.New("modulo by zero")
332-
}
333-
return NewInt(left.Int() % right.Int()), nil
334-
}
335-
if left.Kind() == KindDuration && right.Kind() == KindDuration {
336-
if right.Duration().Seconds() == 0 {
337-
return NewNil(), errors.New("modulo by zero")
338-
}
339-
return NewDuration(Duration{seconds: left.Duration().Seconds() % right.Duration().Seconds()}), nil
340-
}
341-
return NewNil(), fmt.Errorf("unsupported modulo operands")
342-
}
343-
344-
func compareValues(expr *BinaryExpr, left, right Value, cmp func(int) bool) (Value, error) {
345-
switch {
346-
case left.Kind() == KindInt && right.Kind() == KindInt:
347-
diff := left.Int() - right.Int()
348-
switch {
349-
case diff < 0:
350-
return NewBool(cmp(-1)), nil
351-
case diff > 0:
352-
return NewBool(cmp(1)), nil
353-
default:
354-
return NewBool(cmp(0)), nil
355-
}
356-
case (left.Kind() == KindInt || left.Kind() == KindFloat) && (right.Kind() == KindInt || right.Kind() == KindFloat):
357-
lf, rf := left.Float(), right.Float()
358-
switch {
359-
case lf < rf:
360-
return NewBool(cmp(-1)), nil
361-
case lf > rf:
362-
return NewBool(cmp(1)), nil
363-
default:
364-
return NewBool(cmp(0)), nil
365-
}
366-
case left.Kind() == KindString && right.Kind() == KindString:
367-
switch {
368-
case left.String() < right.String():
369-
return NewBool(cmp(-1)), nil
370-
case left.String() > right.String():
371-
return NewBool(cmp(1)), nil
372-
default:
373-
return NewBool(cmp(0)), nil
374-
}
375-
case left.Kind() == KindMoney && right.Kind() == KindMoney:
376-
if left.Money().Currency() != right.Money().Currency() {
377-
return NewNil(), fmt.Errorf("money currency mismatch for comparison")
378-
}
379-
diff := left.Money().Cents() - right.Money().Cents()
380-
switch {
381-
case diff < 0:
382-
return NewBool(cmp(-1)), nil
383-
case diff > 0:
384-
return NewBool(cmp(1)), nil
385-
default:
386-
return NewBool(cmp(0)), nil
387-
}
388-
case left.Kind() == KindDuration && right.Kind() == KindDuration:
389-
diff := left.Duration().Seconds() - right.Duration().Seconds()
390-
switch {
391-
case diff < 0:
392-
return NewBool(cmp(-1)), nil
393-
case diff > 0:
394-
return NewBool(cmp(1)), nil
395-
default:
396-
return NewBool(cmp(0)), nil
397-
}
398-
case left.Kind() == KindTime && right.Kind() == KindTime:
399-
switch {
400-
case left.Time().Before(right.Time()):
401-
return NewBool(cmp(-1)), nil
402-
case left.Time().After(right.Time()):
403-
return NewBool(cmp(1)), nil
404-
default:
405-
return NewBool(cmp(0)), nil
406-
}
407-
default:
408-
return NewNil(), fmt.Errorf("unsupported comparison operands")
409-
}
410-
}

0 commit comments

Comments
 (0)