| Array |
@@ -358,6 +364,30 @@ date("2023-08-14T00:00:00Z")
date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")
```
+## Duration Functions
+
+The following operators can be used to manipulate durations:
+
+```expr
+-1h == -1 * 1h
++1h == 1h
+2 * 1h == 2h
+1h + 1m == 1h1m
+1h - 1m == 59m
+1h / 10m == 6
+1h / 2 == 30m
+```
+
+Some number functions (max, min and abs) are compatible with durations as well.
+
+### round(d1, d2)
+
+Returns the result of rounding d1 to the nearest multiple of d2.
+
+```expr
+round(24h2m, 1h) == 24h
+```
+
## Number Functions
### max(n1, n2)
diff --git a/expr_test.go b/expr_test.go
index eb77408b1..0288a9535 100644
--- a/expr_test.go
+++ b/expr_test.go
@@ -1031,6 +1031,90 @@ func TestExpr(t *testing.T) {
`duration("1s") * .5`,
5e8,
},
+ {
+ `1h == 1h`,
+ true,
+ },
+ {
+ `TimePlusDay - Time >= 24h`,
+ true,
+ },
+ {
+ `1h > 1m`,
+ true,
+ },
+ {
+ `1h < 1m`,
+ false,
+ },
+ {
+ `1h >= 1m`,
+ true,
+ },
+ {
+ `1h <= 1m`,
+ false,
+ },
+ {
+ `1h > 1m`,
+ true,
+ },
+ {
+ `1h + 1m`,
+ time.Hour + time.Minute,
+ },
+ {
+ `7 * 1h`,
+ 7 * time.Hour,
+ },
+ {
+ `1h * 7`,
+ 7 * time.Hour,
+ },
+ {
+ `1s * .5`,
+ 5e8,
+ },
+ {
+ "-1h",
+ -time.Hour,
+ },
+ {
+ "+1h",
+ time.Hour,
+ },
+ {
+ "1h - 1m",
+ 59 * time.Minute,
+ },
+ {
+ "1h - -1m",
+ time.Hour + time.Minute,
+ },
+ {
+ "1h / 2 * 2",
+ time.Hour,
+ },
+ {
+ "1h * 2 / 2",
+ time.Hour,
+ },
+ {
+ "1h5m / 10m",
+ 6.5,
+ },
+ {
+ `date("2023-08-14") - 24h == date("2023-08-13")`,
+ true,
+ },
+ {
+ `date("2023-08-13") + 24h == date("2023-08-14")`,
+ true,
+ },
+ {
+ `let res = 24h; date("2023-08-14") - date("2023-08-13") == res`,
+ true,
+ },
{
`1 /* one */ + 2 // two`,
3,
diff --git a/optimizer/fold.go b/optimizer/fold.go
index 910c92402..da140fc84 100644
--- a/optimizer/fold.go
+++ b/optimizer/fold.go
@@ -4,15 +4,17 @@ import (
"fmt"
"math"
"reflect"
+ "time"
. "github.com/expr-lang/expr/ast"
"github.com/expr-lang/expr/file"
)
var (
- integerType = reflect.TypeOf(0)
- floatType = reflect.TypeOf(float64(0))
- stringType = reflect.TypeOf("")
+ integerType = reflect.TypeOf(0)
+ floatType = reflect.TypeOf(float64(0))
+ durationType = reflect.TypeOf(time.Nanosecond)
+ stringType = reflect.TypeOf("")
)
type fold struct {
@@ -32,6 +34,8 @@ func (fold *fold) Visit(node *Node) {
newNode.SetType(integerType)
case *FloatNode:
newNode.SetType(floatType)
+ case *DurationNode:
+ newNode.SetType(durationType)
case *StringNode:
newNode.SetType(stringType)
default:
@@ -49,6 +53,9 @@ func (fold *fold) Visit(node *Node) {
if i, ok := n.Node.(*FloatNode); ok {
patchWithType(&FloatNode{Value: -i.Value})
}
+ if i, ok := n.Node.(*DurationNode); ok {
+ patchWithType(&DurationNode{Value: -i.Value})
+ }
case "+":
if i, ok := n.Node.(*IntegerNode); ok {
patchWithType(&IntegerNode{Value: i.Value})
@@ -56,6 +63,9 @@ func (fold *fold) Visit(node *Node) {
if i, ok := n.Node.(*FloatNode); ok {
patchWithType(&FloatNode{Value: i.Value})
}
+ if i, ok := n.Node.(*DurationNode); ok {
+ patchWithType(&DurationNode{Value: i.Value})
+ }
case "!", "not":
if a := toBool(n.Node); a != nil {
patch(&BoolNode{Value: !a.Value})
diff --git a/parser/lexer/state.go b/parser/lexer/state.go
index 5d82329eb..b57ae52cc 100644
--- a/parser/lexer/state.go
+++ b/parser/lexer/state.go
@@ -57,10 +57,18 @@ func root(l *lexer) stateFn {
}
func number(l *lexer) stateFn {
+ kind := Number
+ loc, prev, end := l.loc, l.prev, l.end
if !l.scanNumber() {
- return l.error("bad number syntax: %q", l.word())
+ loc2, prev2, end2 := l.loc, l.prev, l.end
+ l.loc, l.prev, l.end = loc, prev, end
+ if !l.scanDuration() {
+ l.loc, l.prev, l.end = loc2, prev2, end2
+ return l.error("bad number syntax: %q", l.word())
+ }
+ kind = Duration
}
- l.emit(Number)
+ l.emit(kind)
return root
}
@@ -102,6 +110,49 @@ func (l *lexer) scanNumber() bool {
return true
}
+func (l *lexer) scanDuration() bool {
+ digits := "0123456789"
+ ok := false
+ for {
+ l.acceptRun(digits)
+ if l.accept(".") {
+ l.acceptRun(digits)
+ }
+ if l.accept("h") {
+ ok = true
+ continue
+ } else if l.accept("m") {
+ l.accept("s")
+ ok = true
+ continue
+ } else if l.accept("s") {
+ ok = true
+ continue
+ } else if l.accept("uµ") {
+ if l.accept("s") {
+ ok = true
+ continue
+ } else {
+ break
+ }
+ } else if l.accept("n") {
+ if l.accept("s") {
+ ok = true
+ continue
+ } else {
+ break
+ }
+ } else {
+ break
+ }
+ }
+ if !ok || utils.IsAlphaNumeric(l.peek()) {
+ l.next()
+ return false
+ }
+ return true
+}
+
func dot(l *lexer) stateFn {
l.next()
if l.accept("0123456789") {
diff --git a/parser/lexer/token.go b/parser/lexer/token.go
index 459fa6905..96e082c54 100644
--- a/parser/lexer/token.go
+++ b/parser/lexer/token.go
@@ -11,6 +11,7 @@ type Kind string
const (
Identifier Kind = "Identifier"
Number Kind = "Number"
+ Duration Kind = "Duration"
String Kind = "String"
Operator Kind = "Operator"
Bracket Kind = "Bracket"
diff --git a/parser/parser.go b/parser/parser.go
index 5f29279bc..e2012a431 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -5,6 +5,7 @@ import (
"math"
"strconv"
"strings"
+ "time"
. "github.com/expr-lang/expr/ast"
"github.com/expr-lang/expr/builtin"
@@ -344,6 +345,17 @@ func (p *parser) parseSecondary() Node {
node.SetLocation(token.Location)
}
return node
+
+ case Duration:
+ p.next()
+ duration, err := time.ParseDuration(token.Value)
+ if err != nil {
+ p.error("invalid duration literal: %v", err)
+ }
+ var node Node = &DurationNode{Value: duration}
+ node.SetLocation(token.Location)
+ return node
+
case String:
p.next()
node := &StringNode{Value: token.Value}
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 2af7635ed..efadca243 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -4,6 +4,7 @@ import (
"fmt"
"strings"
"testing"
+ "time"
. "github.com/expr-lang/expr/ast"
"github.com/expr-lang/expr/parser"
@@ -68,6 +69,55 @@ func TestParse(t *testing.T) {
"1e9",
&FloatNode{Value: 1e9},
},
+ {
+ "1ns",
+ &DurationNode{Value: time.Nanosecond},
+ },
+ {
+ "1us",
+ &DurationNode{Value: time.Microsecond},
+ },
+ {
+ "1µs",
+ &DurationNode{Value: time.Microsecond},
+ },
+ {
+ "1ms",
+ &DurationNode{Value: time.Millisecond},
+ },
+ {
+ "1s",
+ &DurationNode{Value: time.Second},
+ },
+ {
+ "1m",
+ &DurationNode{Value: time.Minute},
+ },
+ {
+ "1h",
+ &DurationNode{Value: time.Hour},
+ },
+ {
+ "-1h",
+ &UnaryNode{Operator: "-",
+ Node: &DurationNode{Value: time.Hour}},
+ },
+ {
+ ".2m",
+ &DurationNode{Value: 12 * time.Second},
+ },
+ {
+ "5m3ms",
+ &DurationNode{Value: 5*time.Minute + 3*time.Millisecond},
+ },
+ {
+ "1h.2m",
+ &DurationNode{Value: time.Hour + 12*time.Second},
+ },
+ {
+ "2m2h2m2h",
+ &DurationNode{Value: 4*time.Hour + 4*time.Minute},
+ },
{
"true",
&BoolNode{Value: true},
@@ -609,6 +659,16 @@ invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6
invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2)
| 1E
| .^
+
+1mt
+bad number syntax: "1m" (1:3)
+ | 1mt
+ | ..^
+
+1h1x1s
+bad number syntax: "1h" (1:3)
+ | 1h1x1s
+ | ..^
`
func TestParse_error(t *testing.T) {
diff --git a/vm/runtime/generated.go b/vm/runtime/generated.go
index 720feb455..2872de8b7 100644
--- a/vm/runtime/generated.go
+++ b/vm/runtime/generated.go
@@ -2808,7 +2808,7 @@ func Multiply(a, b interface{}) interface{} {
panic(fmt.Sprintf("invalid operation: %T * %T", a, b))
}
-func Divide(a, b interface{}) float64 {
+func Divide(a, b interface{}) interface{} {
switch x := a.(type) {
case uint:
switch y := b.(type) {
@@ -2836,6 +2836,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case uint8:
switch y := b.(type) {
@@ -2863,6 +2865,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case uint16:
switch y := b.(type) {
@@ -2890,6 +2894,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case uint32:
switch y := b.(type) {
@@ -2917,6 +2923,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case uint64:
switch y := b.(type) {
@@ -2944,6 +2952,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case int:
switch y := b.(type) {
@@ -2971,6 +2981,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case int8:
switch y := b.(type) {
@@ -2998,6 +3010,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case int16:
switch y := b.(type) {
@@ -3025,6 +3039,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case int32:
switch y := b.(type) {
@@ -3052,6 +3068,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case int64:
switch y := b.(type) {
@@ -3079,6 +3097,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case float32:
switch y := b.(type) {
@@ -3106,6 +3126,8 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
case float64:
switch y := b.(type) {
@@ -3133,6 +3155,37 @@ func Divide(a, b interface{}) float64 {
return float64(x) / float64(y)
case float64:
return float64(x) / float64(y)
+ case time.Duration:
+ return float64(x) / float64(y)
+ }
+ case time.Duration:
+ switch y := b.(type) {
+ case uint:
+ return float64(x) / float64(y)
+ case uint8:
+ return float64(x) / float64(y)
+ case uint16:
+ return float64(x) / float64(y)
+ case uint32:
+ return float64(x) / float64(y)
+ case uint64:
+ return float64(x) / float64(y)
+ case int:
+ return time.Duration(x) / time.Duration(y)
+ case int8:
+ return time.Duration(x) / time.Duration(y)
+ case int16:
+ return time.Duration(x) / time.Duration(y)
+ case int32:
+ return time.Duration(x) / time.Duration(y)
+ case int64:
+ return time.Duration(x) / time.Duration(y)
+ case float32:
+ return time.Duration(x) / time.Duration(y)
+ case float64:
+ return time.Duration(x) / time.Duration(y)
+ case time.Duration:
+ return float64(x) / float64(y)
}
}
panic(fmt.Sprintf("invalid operation: %T / %T", a, b))
diff --git a/vm/runtime/helpers/main.go b/vm/runtime/helpers/main.go
index 66eb68dba..b6164c531 100644
--- a/vm/runtime/helpers/main.go
+++ b/vm/runtime/helpers/main.go
@@ -79,7 +79,11 @@ func cases(op string, xs ...[]string) string {
}
echo(`case %v:`, b)
if op == "/" {
- echo(`return float64(x) / float64(y)`)
+ if isDuration(a) && (isFloat(b) || isInt(b)) {
+ echo(`return time.Duration(x) / time.Duration(y)`)
+ } else {
+ echo(`return float64(x) / float64(y)`)
+ }
} else {
echo(`return %v(x) %v %v(y)`, t, op, t)
}
@@ -274,9 +278,9 @@ func Multiply(a, b interface{}) interface{} {
panic(fmt.Sprintf("invalid operation: %T * %T", a, b))
}
-func Divide(a, b interface{}) float64 {
+func Divide(a, b interface{}) interface{} {
switch x := a.(type) {
- {{ cases "/" }}
+ {{ cases_with_duration "/" }}
}
panic(fmt.Sprintf("invalid operation: %T / %T", a, b))
}
diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go
index 406f85096..ccc26a0a8 100644
--- a/vm/runtime/runtime.go
+++ b/vm/runtime/runtime.go
@@ -6,6 +6,7 @@ import (
"fmt"
"math"
"reflect"
+ "time"
)
func deref(kind reflect.Kind, value reflect.Value) (reflect.Kind, reflect.Value) {
@@ -294,6 +295,8 @@ func Negate(i any) any {
return -v
case uint64:
return -v
+ case time.Duration:
+ return -v
default:
panic(fmt.Sprintf("invalid operation: - %T", v))
}
|