Skip to content

Commit 535a014

Browse files
ascandoneascandone
committed
more overloads
1 parent 80ee485 commit 535a014

File tree

3 files changed

+119
-63
lines changed

3 files changed

+119
-63
lines changed

‎internal/interpreter/evaluate_expr.go

Lines changed: 65 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -148,21 +148,22 @@ func (st *programState) subOp(left parser.ValueExpr, right parser.ValueExpr) (Va
148148
return (*leftValue).evalSub(st, right)
149149
}
150150

151-
func (st *programState) numOp(left parser.ValueExpr, right parser.ValueExpr, op func(left *big.Int, right *big.Int) Value) (Value, InterpreterError) {
152-
parsedLeft, err := evaluateExprAs(st, left, expectNumber)
151+
func (st *programState) eqOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
152+
parsedLeft, err := evaluateExprAs(st, left, expectAnything)
153153
if err != nil {
154154
return nil, err
155155
}
156156

157-
parsedRight, err := evaluateExprAs(st, right, expectNumber)
157+
parsedRight, err := evaluateExprAs(st, right, expectAnything)
158158
if err != nil {
159159
return nil, err
160160
}
161161

162-
return op(parsedLeft, parsedRight), nil
162+
// TODO remove reflect usage
163+
return Bool(reflect.DeepEqual(parsedLeft, parsedRight)), nil
163164
}
164165

165-
func (st *programState) eqOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
166+
func (st *programState) neqOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
166167
parsedLeft, err := evaluateExprAs(st, left, expectAnything)
167168
if err != nil {
168169
return nil, err
@@ -174,66 +175,85 @@ func (st *programState) eqOp(left parser.ValueExpr, right parser.ValueExpr) (Val
174175
}
175176

176177
// TODO remove reflect usage
177-
return Bool(reflect.DeepEqual(parsedLeft, parsedRight)), nil
178+
return Bool(!(reflect.DeepEqual(parsedLeft, parsedRight))), nil
178179
}
179180

180-
func (st *programState) neqOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
181-
parsedLeft, err := evaluateExprAs(st, left, expectAnything)
181+
func (st *programState) ltOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
182+
cmp, err := st.evaluateExprAsCmp(left)
182183
if err != nil {
183184
return nil, err
184185
}
185186

186-
parsedRight, err := evaluateExprAs(st, right, expectAnything)
187+
cmpResult, err := (*cmp).evalCmp(st, right)
187188
if err != nil {
188189
return nil, err
189190
}
190191

191-
// TODO remove reflect usage
192-
return Bool(!(reflect.DeepEqual(parsedLeft, parsedRight))), nil
193-
}
192+
switch *cmpResult {
193+
case -1:
194+
return Bool(true), nil
195+
default:
196+
return Bool(false), nil
197+
}
194198

195-
func (st *programState) ltOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
196-
return st.numOp(left, right, func(left, right *big.Int) Value {
197-
switch left.Cmp(right) {
198-
case -1:
199-
return Bool(true)
200-
default:
201-
return Bool(false)
202-
}
203-
})
204199
}
205200

206201
func (st *programState) gtOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
207-
return st.numOp(left, right, func(left, right *big.Int) Value {
208-
switch left.Cmp(right) {
209-
case 1:
210-
return Bool(true)
211-
default:
212-
return Bool(false)
213-
}
214-
})
202+
cmp, err := st.evaluateExprAsCmp(left)
203+
if err != nil {
204+
return nil, err
205+
}
206+
207+
cmpResult, err := (*cmp).evalCmp(st, right)
208+
if err != nil {
209+
return nil, err
210+
}
211+
212+
switch *cmpResult {
213+
case 1:
214+
return Bool(true), nil
215+
default:
216+
return Bool(false), nil
217+
}
215218
}
216219

217220
func (st *programState) lteOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
218-
return st.numOp(left, right, func(left, right *big.Int) Value {
219-
switch left.Cmp(right) {
220-
case -1, 0:
221-
return Bool(true)
222-
default:
223-
return Bool(false)
224-
}
225-
})
221+
cmp, err := st.evaluateExprAsCmp(left)
222+
if err != nil {
223+
return nil, err
224+
}
225+
226+
cmpResult, err := (*cmp).evalCmp(st, right)
227+
if err != nil {
228+
return nil, err
229+
}
230+
231+
switch *cmpResult {
232+
case -1, 0:
233+
return Bool(true), nil
234+
default:
235+
return Bool(false), nil
236+
}
237+
226238
}
227239

228240
func (st *programState) gteOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {
229-
return st.numOp(left, right, func(left, right *big.Int) Value {
230-
switch left.Cmp(right) {
231-
case 1, 0:
232-
return Bool(true)
233-
default:
234-
return Bool(false)
235-
}
236-
})
241+
cmp, err := st.evaluateExprAsCmp(left)
242+
if err != nil {
243+
return nil, err
244+
}
245+
246+
cmpResult, err := (*cmp).evalCmp(st, right)
247+
if err != nil {
248+
return nil, err
249+
}
250+
251+
switch *cmpResult {
252+
case 1, 0:
253+
return Bool(true), nil
254+
default:
255+
return Bool(false), nil
256+
}
237257
}
238258

239259
func (st *programState) andOp(left parser.ValueExpr, right parser.ValueExpr) (Value, InterpreterError) {

‎internal/interpreter/overloads.go

Lines changed: 54 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -25,21 +25,15 @@ func (m MonetaryInt) evalAdd(st *programState, other parser.ValueExpr) (Value, I
2525
}
2626

2727
func (m Monetary) evalAdd(st *programState, other parser.ValueExpr) (Value, InterpreterError) {
28-
m2, err := evaluateExprAs(st, other, expectMonetary)
28+
b2, err := evaluateExprAs(st, other, expectMonetaryOfAsset(string(m.Asset)))
2929
if err != nil {
3030
return nil, err
3131
}
32-
33-
if m.Asset != m2.Asset {
34-
return nil, MismatchedCurrencyError{
35-
Expected: m.Asset.String(),
36-
Got: m2.Asset.String(),
37-
}
38-
}
39-
32+
b1 := big.Int(m.Amount)
33+
sum := new(big.Int).Add(&b1, b2)
4034
return Monetary{
4135
Asset: m.Asset,
42-
Amount: m.Amount.Add(m2.Amount),
36+
Amount: MonetaryInt(*sum),
4337
}, nil
4438

4539
}
@@ -80,3 +74,53 @@ func (m Monetary) evalSub(st *programState, other parser.ValueExpr) (Value, Inte
8074
}, nil
8175

8276
}
77+
78+
type opCmp interface {
79+
evalCmp(st *programState, other parser.ValueExpr) (*int, InterpreterError)
80+
}
81+
82+
var _ opCmp = (*MonetaryInt)(nil)
83+
var _ opCmp = (*Monetary)(nil)
84+
85+
func (m MonetaryInt) evalCmp(st *programState, other parser.ValueExpr) (*int, InterpreterError) {
86+
b2, err := evaluateExprAs(st, other, expectNumber)
87+
if err != nil {
88+
return nil, err
89+
}
90+
91+
b1 := big.Int(m)
92+
93+
cmp := b1.Cmp(b2)
94+
return &cmp, nil
95+
}
96+
97+
func (m Monetary) evalCmp(st *programState, other parser.ValueExpr) (*int, InterpreterError) {
98+
b2, err := evaluateExprAs(st, other, expectMonetaryOfAsset(string(m.Asset)))
99+
if err != nil {
100+
return nil, err
101+
}
102+
103+
b1 := big.Int(m.Amount)
104+
105+
cmp := b1.Cmp(b2)
106+
return &cmp, nil
107+
}
108+
109+
func (st *programState) evaluateExprAsCmp(expr parser.ValueExpr) (*opCmp, InterpreterError) {
110+
exprCmp, err := evaluateExprAs(st, expr, expectOneOf(
111+
expectMapped(expectMonetary, func(m Monetary) opCmp {
112+
return m
113+
}),
114+
115+
// while "x.map(identity)" is the same as "x", just writing "expectNumber" would't typecheck
116+
expectMapped(expectNumber, func(bi big.Int) opCmp {
117+
return MonetaryInt(bi)
118+
}),
119+
))
120+
121+
if err != nil {
122+
return nil, err
123+
}
124+
125+
return exprCmp, nil
126+
}

‎internal/interpreter/value.go

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -234,14 +234,6 @@ func NewMonetaryInt(n int64) MonetaryInt {
234234
return MonetaryInt(*bi)
235235
}
236236

237-
func (m MonetaryInt) Add(other MonetaryInt) MonetaryInt {
238-
bi := big.Int(m)
239-
otherBi := big.Int(other)
240-
241-
sum := new(big.Int).Add(&bi, &otherBi)
242-
return MonetaryInt(*sum)
243-
}
244-
245237
func (m MonetaryInt) Sub(other MonetaryInt) MonetaryInt {
246238
bi := big.Int(m)
247239
otherBi := big.Int(other)

0 commit comments

Comments
 (0)