diff --git a/promql/engine.go b/promql/engine.go
index c55742a40b..53ac373638 100644
--- a/promql/engine.go
+++ b/promql/engine.go
@@ -36,6 +36,7 @@ import (
 	"github.com/prometheus/prometheus/pkg/labels"
 	"github.com/prometheus/prometheus/pkg/timestamp"
 	"github.com/prometheus/prometheus/pkg/value"
+	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/util/stats"
 )
@@ -188,7 +189,7 @@ func (q *query) Exec(ctx context.Context) *Result {
 	// Exec query.
 	res, warnings, err := q.ng.exec(ctx, q)
 
-	return &Result{Err: err, Value: res, Warnings: warnings}
+	return &Result{Err: err, parser.Value: res, Warnings: warnings}
 }
 
 // contextDone returns an error if the context was canceled or timed out.
@@ -378,7 +379,7 @@ func (ng *Engine) NewRangeQuery(q storage.Queryable, qs string, start, end time.
 	if err != nil {
 		return nil, err
 	}
-	if expr.Type() != ValueTypeVector && expr.Type() != ValueTypeScalar {
+	if expr.Type() != parser.ValueTypeVector && expr.Type() != parser.ValueTypeScalar {
 		return nil, errors.Errorf("invalid expression type %q for range query, must be Scalar or instant Vector", documentedType(expr.Type()))
 	}
 	qry := ng.newQuery(q, expr, start, end, interval)
@@ -431,7 +432,7 @@ func (ng *Engine) newTestQuery(f func(context.Context) error) Query {
 //
 // At this point per query only one EvalStmt is evaluated. Alert and record
 // statements are not handled by the Engine.
-func (ng *Engine) exec(ctx context.Context, q *query) (v Value, w storage.Warnings, err error) {
+func (ng *Engine) exec(ctx context.Context, q *query) (v parser.Value, w storage.Warnings, err error) {
 	ng.metrics.currentQueries.Inc()
 	defer ng.metrics.currentQueries.Dec()
 
@@ -454,7 +455,7 @@ func (ng *Engine) exec(ctx context.Context, q *query) (v Value, w storage.Warnin
 				f = append(f, "error", err)
 			}
 			f = append(f, "stats", stats.NewQueryStats(q.Stats()))
-			if origin := ctx.Value(queryOrigin); origin != nil {
+			if origin := ctx.parser.Value(queryOrigin); origin != nil {
 				for k, v := range origin.(map[string]interface{}) {
 					f = append(f, k, v)
 				}
@@ -515,7 +516,7 @@ func durationMilliseconds(d time.Duration) int64 {
 }
 
 // execEvalStmt evaluates the expression of an evaluation statement for the given time range.
-func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (Value, storage.Warnings, error) {
+func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (parser.Value, storage.Warnings, error) {
 	prepareSpanTimer, ctxPrepare := query.stats.GetSpanTimer(ctx, stats.QueryPreparationTime, ng.metrics.queryPrepareTime)
 	querier, warnings, err := ng.populateSeries(ctxPrepare, query.queryable, s)
 	prepareSpanTimer.Finish()
@@ -566,7 +567,7 @@ func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (
 
 		query.matrix = mat
 		switch s.Expr.Type() {
-		case ValueTypeVector:
+		case parser.ValueTypeVector:
 			// Convert matrix with one value per series into vector.
 			vector := make(Vector, len(mat))
 			for i, s := range mat {
@@ -575,9 +576,9 @@ func (ng *Engine) execEvalStmt(ctx context.Context, query *query, s *EvalStmt) (
 				vector[i] = Sample{Metric: s.Metric, Point: Point{V: s.Points[0].V, T: start}}
 			}
 			return vector, warnings, nil
-		case ValueTypeScalar:
+		case parser.ValueTypeScalar:
 			return Scalar{V: mat[0].Points[0].V, T: start}, warnings, nil
-		case ValueTypeMatrix:
+		case parser.ValueTypeMatrix:
 			return mat, warnings, nil
 		default:
 			panic(errors.Errorf("promql.Engine.exec: unexpected expression type %q", s.Expr.Type()))
@@ -825,7 +826,7 @@ func (ev *evaluator) recover(errp *error) {
 	}
 }
 
-func (ev *evaluator) Eval(expr Expr) (v Value, err error) {
+func (ev *evaluator) Eval(expr Expr) (v parser.Value, err error) {
 	defer ev.recover(&err)
 	return ev.eval(expr), nil
 }
@@ -890,7 +891,7 @@ func (enh *EvalNodeHelper) signatureFunc(on bool, names ...string) func(labels.L
 // the given function with the values computed for each expression at that
 // step.  The return value is the combination into time series of all the
 // function call results.
-func (ev *evaluator) rangeEval(f func([]Value, *EvalNodeHelper) Vector, exprs ...Expr) Matrix {
+func (ev *evaluator) rangeEval(f func([]parser.Value, *EvalNodeHelper) Vector, exprs ...Expr) Matrix {
 	numSteps := int((ev.endTimestamp-ev.startTimestamp)/ev.interval) + 1
 	matrixes := make([]Matrix, len(exprs))
 	origMatrixes := make([]Matrix, len(exprs))
@@ -898,7 +899,7 @@ func (ev *evaluator) rangeEval(f func([]Value, *EvalNodeHelper) Vector, exprs ..
 
 	for i, e := range exprs {
 		// Functions will take string arguments from the expressions, not the values.
-		if e != nil && e.Type() != ValueTypeString {
+		if e != nil && e.Type() != parser.ValueTypeString {
 			// ev.currentSamples will be updated to the correct value within the ev.eval call.
 			matrixes[i] = ev.eval(e).(Matrix)
 
@@ -909,8 +910,8 @@ func (ev *evaluator) rangeEval(f func([]Value, *EvalNodeHelper) Vector, exprs ..
 		}
 	}
 
-	vectors := make([]Vector, len(exprs)) // Input vectors for the function.
-	args := make([]Value, len(exprs))     // Argument to function.
+	vectors := make([]Vector, len(exprs))    // Input vectors for the function.
+	args := make([]parser.Value, len(exprs)) // Argument to function.
 	// Create an output vector that is as big as the input matrix with
 	// the most time series.
 	biggestLen := 1
@@ -1029,7 +1030,7 @@ func (ev *evaluator) evalSubquery(subq *SubqueryExpr) *MatrixSelector {
 }
 
 // eval evaluates the given expression as the given AST expression node requires.
-func (ev *evaluator) eval(expr Expr) Value {
+func (ev *evaluator) eval(expr Expr) parser.Value {
 	// This is the top-level evaluation method.
 	// Thus, we check for timeout/cancellation here.
 	if err := contextDone(ev.ctx, "expression evaluation"); err != nil {
@@ -1041,11 +1042,11 @@ func (ev *evaluator) eval(expr Expr) Value {
 	case *AggregateExpr:
 		unwrapParenExpr(&e.Param)
 		if s, ok := e.Param.(*StringLiteral); ok {
-			return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+			return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 				return ev.aggregation(e.Op, e.Grouping, e.Without, s.Val, v[0].(Vector), enh)
 			}, e.Expr)
 		}
-		return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+		return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 			var param float64
 			if e.Param != nil {
 				param = v[0].(Vector)[0].V
@@ -1060,8 +1061,8 @@ func (ev *evaluator) eval(expr Expr) Value {
 			// a vector selector.
 			vs, ok := e.Args[0].(*VectorSelector)
 			if ok {
-				return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
-					return e.Func.Call([]Value{ev.vectorSelector(vs, enh.ts)}, e.Args, enh)
+				return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
+					return e.Func.Call([]parser.Value{ev.vectorSelector(vs, enh.ts)}, e.Args, enh)
 				})
 			}
 		}
@@ -1088,12 +1089,12 @@ func (ev *evaluator) eval(expr Expr) Value {
 		}
 		if !matrixArg {
 			// Does not have a matrix argument.
-			return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+			return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 				return e.Func.Call(v, e.Args, enh)
 			}, e.Args...)
 		}
 
-		inArgs := make([]Value, len(e.Args))
+		inArgs := make([]parser.Value, len(e.Args))
 		// Evaluate any non-matrix arguments.
 		otherArgs := make([]Matrix, len(e.Args))
 		otherInArgs := make([]Vector, len(e.Args))
@@ -1240,44 +1241,44 @@ func (ev *evaluator) eval(expr Expr) Value {
 
 	case *BinaryExpr:
 		switch lt, rt := e.LHS.Type(), e.RHS.Type(); {
-		case lt == ValueTypeScalar && rt == ValueTypeScalar:
-			return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+		case lt == parser.ValueTypeScalar && rt == parser.ValueTypeScalar:
+			return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 				val := scalarBinop(e.Op, v[0].(Vector)[0].Point.V, v[1].(Vector)[0].Point.V)
 				return append(enh.out, Sample{Point: Point{V: val}})
 			}, e.LHS, e.RHS)
-		case lt == ValueTypeVector && rt == ValueTypeVector:
+		case lt == parser.ValueTypeVector && rt == parser.ValueTypeVector:
 			switch e.Op {
 			case LAND:
-				return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+				return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 					return ev.VectorAnd(v[0].(Vector), v[1].(Vector), e.VectorMatching, enh)
 				}, e.LHS, e.RHS)
 			case LOR:
-				return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+				return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 					return ev.VectorOr(v[0].(Vector), v[1].(Vector), e.VectorMatching, enh)
 				}, e.LHS, e.RHS)
 			case LUNLESS:
-				return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+				return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 					return ev.VectorUnless(v[0].(Vector), v[1].(Vector), e.VectorMatching, enh)
 				}, e.LHS, e.RHS)
 			default:
-				return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+				return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 					return ev.VectorBinop(e.Op, v[0].(Vector), v[1].(Vector), e.VectorMatching, e.ReturnBool, enh)
 				}, e.LHS, e.RHS)
 			}
 
-		case lt == ValueTypeVector && rt == ValueTypeScalar:
-			return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+		case lt == parser.ValueTypeVector && rt == parser.ValueTypeScalar:
+			return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 				return ev.VectorscalarBinop(e.Op, v[0].(Vector), Scalar{V: v[1].(Vector)[0].Point.V}, false, e.ReturnBool, enh)
 			}, e.LHS, e.RHS)
 
-		case lt == ValueTypeScalar && rt == ValueTypeVector:
-			return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+		case lt == parser.ValueTypeScalar && rt == parser.ValueTypeVector:
+			return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 				return ev.VectorscalarBinop(e.Op, v[1].(Vector), Scalar{V: v[0].(Vector)[0].Point.V}, true, e.ReturnBool, enh)
 			}, e.LHS, e.RHS)
 		}
 
 	case *NumberLiteral:
-		return ev.rangeEval(func(v []Value, enh *EvalNodeHelper) Vector {
+		return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
 			return append(enh.out, Sample{Point: Point{V: e.Val}})
 		})
 
@@ -1400,7 +1401,7 @@ func (ev *evaluator) vectorSelectorSingle(it *storage.BufferedSeriesIterator, no
 	}
 
 	if ok {
-		t, v = it.Values()
+		t, v = it.parser.Values()
 	}
 
 	if !ok || t > refTime {
@@ -1505,7 +1506,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
 		if value.IsStaleNaN(v) {
 			continue
 		}
-		// Values in the buffer are guaranteed to be smaller than maxt.
+		// parser.Values in the buffer are guaranteed to be smaller than maxt.
 		if t >= mint {
 			if ev.currentSamples >= ev.maxSamples {
 				ev.error(ErrTooManySamples(env))
@@ -1516,7 +1517,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
 	}
 	// The seeked sample might also be in the range.
 	if ok {
-		t, v := it.Values()
+		t, v := it.parser.Values()
 		if t == maxt && !value.IsStaleNaN(v) {
 			if ev.currentSamples >= ev.maxSamples {
 				ev.error(ErrTooManySamples(env))
diff --git a/promql/engine_test.go b/promql/engine_test.go
index 78f6711dc9..bfec091324 100644
--- a/promql/engine_test.go
+++ b/promql/engine_test.go
@@ -26,6 +26,7 @@ import (
 	"github.com/go-kit/kit/log"
 
 	"github.com/prometheus/prometheus/pkg/labels"
+	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/util/testutil"
 )
@@ -522,7 +523,7 @@ load 10s
 
 	cases := []struct {
 		Query       string
-		Result      Value
+		Result      parser.Value
 		Start       time.Time
 		End         time.Time
 		Interval    time.Duration
@@ -604,7 +605,7 @@ load 10s
 		}
 
 		testutil.Ok(t, res.Err)
-		testutil.Equals(t, c.Result, res.Value)
+		testutil.Equals(t, c.Result, res.parser.Value)
 	}
 
 }
@@ -822,7 +823,7 @@ load 10s
 
 		res := qry.Exec(test.Context())
 		testutil.Equals(t, c.Result.Err, res.Err)
-		testutil.Equals(t, c.Result.Value, res.Value)
+		testutil.Equals(t, c.Result.parser.Value, res.parser.Value)
 	}
 }
 
@@ -1106,9 +1107,9 @@ func TestSubquerySelector(t *testing.T) {
 
 			res := qry.Exec(test.Context())
 			testutil.Equals(t, c.Result.Err, res.Err)
-			mat := res.Value.(Matrix)
+			mat := res.parser.Value.(Matrix)
 			sort.Sort(mat)
-			testutil.Equals(t, c.Result.Value, mat)
+			testutil.Equals(t, c.Result.parser.Value, mat)
 		}
 	}
 }
diff --git a/promql/functions.go b/promql/functions.go
index 4765965ab3..7b4c8724cc 100644
--- a/promql/functions.go
+++ b/promql/functions.go
@@ -25,15 +25,16 @@ import (
 	"github.com/prometheus/common/model"
 
 	"github.com/prometheus/prometheus/pkg/labels"
+	"github.com/prometheus/prometheus/promql/parser"
 )
 
 // Function represents a function of the expression language and is
 // used by function nodes.
 type Function struct {
 	Name       string
-	ArgTypes   []ValueType
+	ArgTypes   []parser.ValueType
 	Variadic   int
-	ReturnType ValueType
+	ReturnType parser.ValueType
 
 	// vals is a list of the evaluated arguments for the function call.
 	//    For range vectors it will be a Matrix with one series, instant vectors a
@@ -48,11 +49,11 @@ type Function struct {
 	// Instant vector functions need only return a vector with the right values and
 	//     metrics, the timestamp are not needed.
 	// Scalar results should be returned as the value of a sample in a Vector.
-	Call func(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
+	Call func(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector
 }
 
 // === time() float64 ===
-func funcTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return Vector{Sample{Point: Point{
 		V: float64(enh.ts) / 1000,
 	}}}
@@ -62,7 +63,7 @@ func funcTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 // It calculates the rate (allowing for counter resets if isCounter is true),
 // extrapolates if the first/last sample is close to the boundary, and returns
 // the result as either per-second (if isRate is true) or overall.
-func extrapolatedRate(vals []Value, args Expressions, enh *EvalNodeHelper, isCounter bool, isRate bool) Vector {
+func extrapolatedRate(vals []parser.Value, args Expressions, enh *EvalNodeHelper, isCounter bool, isRate bool) Vector {
 	ms := args[0].(*MatrixSelector)
 	vs := ms.VectorSelector.(*VectorSelector)
 
@@ -137,32 +138,32 @@ func extrapolatedRate(vals []Value, args Expressions, enh *EvalNodeHelper, isCou
 	})
 }
 
-// === delta(Matrix ValueTypeMatrix) Vector ===
-func funcDelta(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === delta(Matrix parser.ValueTypeMatrix) Vector ===
+func funcDelta(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return extrapolatedRate(vals, args, enh, false, false)
 }
 
-// === rate(node ValueTypeMatrix) Vector ===
-func funcRate(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === rate(node parser.ValueTypeMatrix) Vector ===
+func funcRate(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return extrapolatedRate(vals, args, enh, true, true)
 }
 
-// === increase(node ValueTypeMatrix) Vector ===
-func funcIncrease(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === increase(node parser.ValueTypeMatrix) Vector ===
+func funcIncrease(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return extrapolatedRate(vals, args, enh, true, false)
 }
 
-// === irate(node ValueTypeMatrix) Vector ===
-func funcIrate(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === irate(node parser.ValueTypeMatrix) Vector ===
+func funcIrate(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return instantValue(vals, enh.out, true)
 }
 
 // === idelta(node model.ValMatrix) Vector ===
-func funcIdelta(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcIdelta(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return instantValue(vals, enh.out, false)
 }
 
-func instantValue(vals []Value, out Vector, isRate bool) Vector {
+func instantValue(vals []parser.Value, out Vector, isRate bool) Vector {
 	samples := vals[0].(Matrix)[0]
 	// No sense in trying to compute a rate without at least two points. Drop
 	// this Vector element.
@@ -218,7 +219,7 @@ func calcTrendValue(i int, sf, tf, s0, s1, b float64) float64 {
 // data. A lower smoothing factor increases the influence of historical data. The trend factor (0 < tf < 1) affects
 // how trends in historical data will affect the current data. A higher trend factor increases the influence.
 // of trends. Algorithm taken from https://en.wikipedia.org/wiki/Exponential_smoothing titled: "Double exponential smoothing".
-func funcHoltWinters(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcHoltWinters(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	samples := vals[0].(Matrix)[0]
 
 	// The smoothing factor argument.
@@ -266,8 +267,8 @@ func funcHoltWinters(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
 	})
 }
 
-// === sort(node ValueTypeVector) Vector ===
-func funcSort(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === sort(node parser.ValueTypeVector) Vector ===
+func funcSort(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	// NaN should sort to the bottom, so take descending sort with NaN first and
 	// reverse it.
 	byValueSorter := vectorByReverseValueHeap(vals[0].(Vector))
@@ -275,8 +276,8 @@ func funcSort(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return Vector(byValueSorter)
 }
 
-// === sortDesc(node ValueTypeVector) Vector ===
-func funcSortDesc(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === sortDesc(node parser.ValueTypeVector) Vector ===
+func funcSortDesc(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	// NaN should sort to the bottom, so take ascending sort with NaN first and
 	// reverse it.
 	byValueSorter := vectorByValueHeap(vals[0].(Vector))
@@ -284,8 +285,8 @@ func funcSortDesc(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return Vector(byValueSorter)
 }
 
-// === clamp_max(Vector ValueTypeVector, max Scalar) Vector ===
-func funcClampMax(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === clamp_max(Vector parser.ValueTypeVector, max Scalar) Vector ===
+func funcClampMax(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	vec := vals[0].(Vector)
 	max := vals[1].(Vector)[0].Point.V
 	for _, el := range vec {
@@ -297,8 +298,8 @@ func funcClampMax(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return enh.out
 }
 
-// === clamp_min(Vector ValueTypeVector, min Scalar) Vector ===
-func funcClampMin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === clamp_min(Vector parser.ValueTypeVector, min Scalar) Vector ===
+func funcClampMin(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	vec := vals[0].(Vector)
 	min := vals[1].(Vector)[0].Point.V
 	for _, el := range vec {
@@ -310,8 +311,8 @@ func funcClampMin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return enh.out
 }
 
-// === round(Vector ValueTypeVector, toNearest=1 Scalar) Vector ===
-func funcRound(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === round(Vector parser.ValueTypeVector, toNearest=1 Scalar) Vector ===
+func funcRound(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	vec := vals[0].(Vector)
 	// round returns a number rounded to toNearest.
 	// Ties are solved by rounding up.
@@ -332,8 +333,8 @@ func funcRound(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return enh.out
 }
 
-// === Scalar(node ValueTypeVector) Scalar ===
-func funcScalar(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === Scalar(node parser.ValueTypeVector) Scalar ===
+func funcScalar(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	v := vals[0].(Vector)
 	if len(v) != 1 {
 		return append(enh.out, Sample{
@@ -345,7 +346,7 @@ func funcScalar(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	})
 }
 
-func aggrOverTime(vals []Value, enh *EvalNodeHelper, aggrFn func([]Point) float64) Vector {
+func aggrOverTime(vals []parser.Value, enh *EvalNodeHelper, aggrFn func([]Point) float64) Vector {
 	el := vals[0].(Matrix)[0]
 
 	return append(enh.out, Sample{
@@ -353,8 +354,8 @@ func aggrOverTime(vals []Value, enh *EvalNodeHelper, aggrFn func([]Point) float6
 	})
 }
 
-// === avg_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcAvgOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === avg_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcAvgOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return aggrOverTime(vals, enh, func(values []Point) float64 {
 		var mean, count float64
 		for _, v := range values {
@@ -365,16 +366,16 @@ func funcAvgOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
 	})
 }
 
-// === count_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcCountOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === count_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcCountOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return aggrOverTime(vals, enh, func(values []Point) float64 {
 		return float64(len(values))
 	})
 }
 
-// === floor(Vector ValueTypeVector) Vector ===
-// === max_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcMaxOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === floor(Vector parser.ValueTypeVector) Vector ===
+// === max_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcMaxOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return aggrOverTime(vals, enh, func(values []Point) float64 {
 		max := values[0].V
 		for _, v := range values {
@@ -386,8 +387,8 @@ func funcMaxOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
 	})
 }
 
-// === min_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcMinOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === min_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcMinOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return aggrOverTime(vals, enh, func(values []Point) float64 {
 		min := values[0].V
 		for _, v := range values {
@@ -399,8 +400,8 @@ func funcMinOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
 	})
 }
 
-// === sum_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcSumOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === sum_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcSumOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return aggrOverTime(vals, enh, func(values []Point) float64 {
 		var sum float64
 		for _, v := range values {
@@ -410,8 +411,8 @@ func funcSumOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector
 	})
 }
 
-// === quantile_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcQuantileOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === quantile_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcQuantileOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	q := vals[0].(Vector)[0].V
 	el := vals[1].(Matrix)[0]
 
@@ -424,8 +425,8 @@ func funcQuantileOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) V
 	})
 }
 
-// === stddev_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcStddevOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === stddev_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcStddevOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return aggrOverTime(vals, enh, func(values []Point) float64 {
 		var aux, count, mean float64
 		for _, v := range values {
@@ -438,8 +439,8 @@ func funcStddevOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vec
 	})
 }
 
-// === stdvar_over_time(Matrix ValueTypeMatrix) Vector ===
-func funcStdvarOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === stdvar_over_time(Matrix parser.ValueTypeMatrix) Vector ===
+func funcStdvarOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return aggrOverTime(vals, enh, func(values []Point) float64 {
 		var aux, count, mean float64
 		for _, v := range values {
@@ -452,8 +453,8 @@ func funcStdvarOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vec
 	})
 }
 
-// === absent(Vector ValueTypeVector) Vector ===
-func funcAbsent(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === absent(Vector parser.ValueTypeVector) Vector ===
+func funcAbsent(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	if len(vals[0].(Vector)) > 0 {
 		return enh.out
 	}
@@ -464,19 +465,19 @@ func funcAbsent(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 		})
 }
 
-// === absent_over_time(Vector ValueTypeMatrix) Vector ===
+// === absent_over_time(Vector parser.ValueTypeMatrix) Vector ===
 // As this function has a matrix as argument, it does not get all the Series.
 // This function will return 1 if the matrix has at least one element.
 // Due to engine optimization, this function is only called when this condition is true.
 // Then, the engine post-processes the results to get the expected output.
-func funcAbsentOverTime(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcAbsentOverTime(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return append(enh.out,
 		Sample{
 			Point: Point{V: 1},
 		})
 }
 
-func simpleFunc(vals []Value, enh *EvalNodeHelper, f func(float64) float64) Vector {
+func simpleFunc(vals []parser.Value, enh *EvalNodeHelper, f func(float64) float64) Vector {
 	for _, el := range vals[0].(Vector) {
 		enh.out = append(enh.out, Sample{
 			Metric: enh.dropMetricName(el.Metric),
@@ -486,48 +487,48 @@ func simpleFunc(vals []Value, enh *EvalNodeHelper, f func(float64) float64) Vect
 	return enh.out
 }
 
-// === abs(Vector ValueTypeVector) Vector ===
-func funcAbs(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === abs(Vector parser.ValueTypeVector) Vector ===
+func funcAbs(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Abs)
 }
 
-// === ceil(Vector ValueTypeVector) Vector ===
-func funcCeil(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === ceil(Vector parser.ValueTypeVector) Vector ===
+func funcCeil(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Ceil)
 }
 
-// === floor(Vector ValueTypeVector) Vector ===
-func funcFloor(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === floor(Vector parser.ValueTypeVector) Vector ===
+func funcFloor(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Floor)
 }
 
-// === exp(Vector ValueTypeVector) Vector ===
-func funcExp(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === exp(Vector parser.ValueTypeVector) Vector ===
+func funcExp(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Exp)
 }
 
 // === sqrt(Vector VectorNode) Vector ===
-func funcSqrt(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcSqrt(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Sqrt)
 }
 
-// === ln(Vector ValueTypeVector) Vector ===
-func funcLn(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === ln(Vector parser.ValueTypeVector) Vector ===
+func funcLn(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Log)
 }
 
-// === log2(Vector ValueTypeVector) Vector ===
-func funcLog2(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === log2(Vector parser.ValueTypeVector) Vector ===
+func funcLog2(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Log2)
 }
 
-// === log10(Vector ValueTypeVector) Vector ===
-func funcLog10(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === log10(Vector parser.ValueTypeVector) Vector ===
+func funcLog10(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return simpleFunc(vals, enh, math.Log10)
 }
 
-// === timestamp(Vector ValueTypeVector) Vector ===
-func funcTimestamp(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === timestamp(Vector parser.ValueTypeVector) Vector ===
+func funcTimestamp(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	vec := vals[0].(Vector)
 	for _, el := range vec {
 		enh.out = append(enh.out, Sample{
@@ -563,8 +564,8 @@ func linearRegression(samples []Point, interceptTime int64) (slope, intercept fl
 	return slope, intercept
 }
 
-// === deriv(node ValueTypeMatrix) Vector ===
-func funcDeriv(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === deriv(node parser.ValueTypeMatrix) Vector ===
+func funcDeriv(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	samples := vals[0].(Matrix)[0]
 
 	// No sense in trying to compute a derivative without at least two points.
@@ -582,8 +583,8 @@ func funcDeriv(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	})
 }
 
-// === predict_linear(node ValueTypeMatrix, k ValueTypeScalar) Vector ===
-func funcPredictLinear(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === predict_linear(node parser.ValueTypeMatrix, k parser.ValueTypeScalar) Vector ===
+func funcPredictLinear(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	samples := vals[0].(Matrix)[0]
 	duration := vals[1].(Vector)[0].V
 
@@ -599,8 +600,8 @@ func funcPredictLinear(vals []Value, args Expressions, enh *EvalNodeHelper) Vect
 	})
 }
 
-// === histogram_quantile(k ValueTypeScalar, Vector ValueTypeVector) Vector ===
-func funcHistogramQuantile(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === histogram_quantile(k parser.ValueTypeScalar, Vector parser.ValueTypeVector) Vector ===
+func funcHistogramQuantile(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	q := vals[0].(Vector)[0].V
 	inVec := vals[1].(Vector)
 	sigf := enh.signatureFunc(false, excludedLabels...)
@@ -647,8 +648,8 @@ func funcHistogramQuantile(vals []Value, args Expressions, enh *EvalNodeHelper)
 	return enh.out
 }
 
-// === resets(Matrix ValueTypeMatrix) Vector ===
-func funcResets(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === resets(Matrix parser.ValueTypeMatrix) Vector ===
+func funcResets(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	samples := vals[0].(Matrix)[0]
 
 	resets := 0
@@ -666,8 +667,8 @@ func funcResets(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	})
 }
 
-// === changes(Matrix ValueTypeMatrix) Vector ===
-func funcChanges(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === changes(Matrix parser.ValueTypeMatrix) Vector ===
+func funcChanges(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	samples := vals[0].(Matrix)[0]
 
 	changes := 0
@@ -685,8 +686,8 @@ func funcChanges(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 	})
 }
 
-// === label_replace(Vector ValueTypeVector, dst_label, replacement, src_labelname, regex ValueTypeString) Vector ===
-func funcLabelReplace(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+// === label_replace(Vector parser.ValueTypeVector, dst_label, replacement, src_labelname, regex parser.ValueTypeString) Vector ===
+func funcLabelReplace(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	var (
 		vector   = vals[0].(Vector)
 		dst      = args[1].(*StringLiteral).Val
@@ -740,7 +741,7 @@ func funcLabelReplace(vals []Value, args Expressions, enh *EvalNodeHelper) Vecto
 }
 
 // === Vector(s Scalar) Vector ===
-func funcVector(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcVector(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return append(enh.out,
 		Sample{
 			Metric: labels.Labels{},
@@ -749,7 +750,7 @@ func funcVector(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 }
 
 // === label_join(vector model.ValVector, dest_labelname, separator, src_labelname...) Vector ===
-func funcLabelJoin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcLabelJoin(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	var (
 		vector    = vals[0].(Vector)
 		dst       = args[1].(*StringLiteral).Val
@@ -807,7 +808,7 @@ func funcLabelJoin(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 }
 
 // Common code for date related functions.
-func dateWrapper(vals []Value, enh *EvalNodeHelper, f func(time.Time) float64) Vector {
+func dateWrapper(vals []parser.Value, enh *EvalNodeHelper, f func(time.Time) float64) Vector {
 	if len(vals) == 0 {
 		return append(enh.out,
 			Sample{
@@ -827,49 +828,49 @@ func dateWrapper(vals []Value, enh *EvalNodeHelper, f func(time.Time) float64) V
 }
 
 // === days_in_month(v Vector) Scalar ===
-func funcDaysInMonth(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcDaysInMonth(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return dateWrapper(vals, enh, func(t time.Time) float64 {
 		return float64(32 - time.Date(t.Year(), t.Month(), 32, 0, 0, 0, 0, time.UTC).Day())
 	})
 }
 
 // === day_of_month(v Vector) Scalar ===
-func funcDayOfMonth(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcDayOfMonth(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return dateWrapper(vals, enh, func(t time.Time) float64 {
 		return float64(t.Day())
 	})
 }
 
 // === day_of_week(v Vector) Scalar ===
-func funcDayOfWeek(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcDayOfWeek(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return dateWrapper(vals, enh, func(t time.Time) float64 {
 		return float64(t.Weekday())
 	})
 }
 
 // === hour(v Vector) Scalar ===
-func funcHour(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcHour(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return dateWrapper(vals, enh, func(t time.Time) float64 {
 		return float64(t.Hour())
 	})
 }
 
 // === minute(v Vector) Scalar ===
-func funcMinute(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcMinute(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return dateWrapper(vals, enh, func(t time.Time) float64 {
 		return float64(t.Minute())
 	})
 }
 
 // === month(v Vector) Scalar ===
-func funcMonth(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcMonth(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return dateWrapper(vals, enh, func(t time.Time) float64 {
 		return float64(t.Month())
 	})
 }
 
 // === year(v Vector) Scalar ===
-func funcYear(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
+func funcYear(vals []parser.Value, args Expressions, enh *EvalNodeHelper) Vector {
 	return dateWrapper(vals, enh, func(t time.Time) float64 {
 		return float64(t.Year())
 	})
@@ -879,293 +880,293 @@ func funcYear(vals []Value, args Expressions, enh *EvalNodeHelper) Vector {
 var Functions = map[string]*Function{
 	"abs": {
 		Name:       "abs",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcAbs,
 	},
 	"absent": {
 		Name:       "absent",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcAbsent,
 	},
 	"absent_over_time": {
 		Name:       "absent_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcAbsentOverTime,
 	},
 	"avg_over_time": {
 		Name:       "avg_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcAvgOverTime,
 	},
 	"ceil": {
 		Name:       "ceil",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcCeil,
 	},
 	"changes": {
 		Name:       "changes",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcChanges,
 	},
 	"clamp_max": {
 		Name:       "clamp_max",
-		ArgTypes:   []ValueType{ValueTypeVector, ValueTypeScalar},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeScalar},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcClampMax,
 	},
 	"clamp_min": {
 		Name:       "clamp_min",
-		ArgTypes:   []ValueType{ValueTypeVector, ValueTypeScalar},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeScalar},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcClampMin,
 	},
 	"count_over_time": {
 		Name:       "count_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcCountOverTime,
 	},
 	"days_in_month": {
 		Name:       "days_in_month",
-		ArgTypes:   []ValueType{ValueTypeVector},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcDaysInMonth,
 	},
 	"day_of_month": {
 		Name:       "day_of_month",
-		ArgTypes:   []ValueType{ValueTypeVector},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcDayOfMonth,
 	},
 	"day_of_week": {
 		Name:       "day_of_week",
-		ArgTypes:   []ValueType{ValueTypeVector},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcDayOfWeek,
 	},
 	"delta": {
 		Name:       "delta",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcDelta,
 	},
 	"deriv": {
 		Name:       "deriv",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcDeriv,
 	},
 	"exp": {
 		Name:       "exp",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcExp,
 	},
 	"floor": {
 		Name:       "floor",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcFloor,
 	},
 	"histogram_quantile": {
 		Name:       "histogram_quantile",
-		ArgTypes:   []ValueType{ValueTypeScalar, ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeScalar, parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcHistogramQuantile,
 	},
 	"holt_winters": {
 		Name:       "holt_winters",
-		ArgTypes:   []ValueType{ValueTypeMatrix, ValueTypeScalar, ValueTypeScalar},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix, parser.ValueTypeScalar, parser.ValueTypeScalar},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcHoltWinters,
 	},
 	"hour": {
 		Name:       "hour",
-		ArgTypes:   []ValueType{ValueTypeVector},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcHour,
 	},
 	"idelta": {
 		Name:       "idelta",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcIdelta,
 	},
 	"increase": {
 		Name:       "increase",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcIncrease,
 	},
 	"irate": {
 		Name:       "irate",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcIrate,
 	},
 	"label_replace": {
 		Name:       "label_replace",
-		ArgTypes:   []ValueType{ValueTypeVector, ValueTypeString, ValueTypeString, ValueTypeString, ValueTypeString},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeString, parser.ValueTypeString, parser.ValueTypeString, parser.ValueTypeString},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcLabelReplace,
 	},
 	"label_join": {
 		Name:       "label_join",
-		ArgTypes:   []ValueType{ValueTypeVector, ValueTypeString, ValueTypeString, ValueTypeString},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeString, parser.ValueTypeString, parser.ValueTypeString},
 		Variadic:   -1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcLabelJoin,
 	},
 	"ln": {
 		Name:       "ln",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcLn,
 	},
 	"log10": {
 		Name:       "log10",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcLog10,
 	},
 	"log2": {
 		Name:       "log2",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcLog2,
 	},
 	"max_over_time": {
 		Name:       "max_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcMaxOverTime,
 	},
 	"min_over_time": {
 		Name:       "min_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcMinOverTime,
 	},
 	"minute": {
 		Name:       "minute",
-		ArgTypes:   []ValueType{ValueTypeVector},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcMinute,
 	},
 	"month": {
 		Name:       "month",
-		ArgTypes:   []ValueType{ValueTypeVector},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcMonth,
 	},
 	"predict_linear": {
 		Name:       "predict_linear",
-		ArgTypes:   []ValueType{ValueTypeMatrix, ValueTypeScalar},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix, parser.ValueTypeScalar},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcPredictLinear,
 	},
 	"quantile_over_time": {
 		Name:       "quantile_over_time",
-		ArgTypes:   []ValueType{ValueTypeScalar, ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeScalar, parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcQuantileOverTime,
 	},
 	"rate": {
 		Name:       "rate",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcRate,
 	},
 	"resets": {
 		Name:       "resets",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcResets,
 	},
 	"round": {
 		Name:       "round",
-		ArgTypes:   []ValueType{ValueTypeVector, ValueTypeScalar},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector, parser.ValueTypeScalar},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcRound,
 	},
 	"scalar": {
 		Name:       "scalar",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeScalar,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeScalar,
 		Call:       funcScalar,
 	},
 	"sort": {
 		Name:       "sort",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcSort,
 	},
 	"sort_desc": {
 		Name:       "sort_desc",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcSortDesc,
 	},
 	"sqrt": {
 		Name:       "sqrt",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcSqrt,
 	},
 	"stddev_over_time": {
 		Name:       "stddev_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcStddevOverTime,
 	},
 	"stdvar_over_time": {
 		Name:       "stdvar_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcStdvarOverTime,
 	},
 	"sum_over_time": {
 		Name:       "sum_over_time",
-		ArgTypes:   []ValueType{ValueTypeMatrix},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeMatrix},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcSumOverTime,
 	},
 	"time": {
 		Name:       "time",
-		ArgTypes:   []ValueType{},
-		ReturnType: ValueTypeScalar,
+		ArgTypes:   []parser.ValueType{},
+		ReturnType: parser.ValueTypeScalar,
 		Call:       funcTime,
 	},
 	"timestamp": {
 		Name:       "timestamp",
-		ArgTypes:   []ValueType{ValueTypeVector},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcTimestamp,
 	},
 	"vector": {
 		Name:       "vector",
-		ArgTypes:   []ValueType{ValueTypeScalar},
-		ReturnType: ValueTypeVector,
+		ArgTypes:   []parser.ValueType{parser.ValueTypeScalar},
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcVector,
 	},
 	"year": {
 		Name:       "year",
-		ArgTypes:   []ValueType{ValueTypeVector},
+		ArgTypes:   []parser.ValueType{parser.ValueTypeVector},
 		Variadic:   1,
-		ReturnType: ValueTypeVector,
+		ReturnType: parser.ValueTypeVector,
 		Call:       funcYear,
 	},
 }
@@ -1255,7 +1256,7 @@ func createLabelsForAbsentFunction(expr Expr) labels.Labels {
 			continue
 		}
 		if ma.Type == labels.MatchEqual && !m.Has(ma.Name) {
-			m = labels.NewBuilder(m).Set(ma.Name, ma.Value).Labels()
+			m = labels.NewBuilder(m).Set(ma.Name, ma.parser.Value).Labels()
 		} else {
 			empty = append(empty, ma.Name)
 		}
diff --git a/promql/test.go b/promql/test.go
index 8c2b0497fc..eafdc28bc9 100644
--- a/promql/test.go
+++ b/promql/test.go
@@ -27,6 +27,7 @@ import (
 	"github.com/prometheus/common/model"
 
 	"github.com/prometheus/prometheus/pkg/labels"
+	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/util/teststorage"
 	"github.com/prometheus/prometheus/util/testutil"
@@ -357,7 +358,7 @@ func (ev *evalCmd) expect(pos int, m labels.Labels, vals ...sequenceValue) {
 }
 
 // compareResult compares the result value with the defined expectation.
-func (ev *evalCmd) compareResult(result Value) error {
+func (ev *evalCmd) compareResult(result parser.Value) error {
 	switch val := result.(type) {
 	case Matrix:
 		return errors.New("received range result on instant evaluation")
@@ -458,7 +459,7 @@ func (t *Test) exec(tc testCommand) error {
 			return errors.Errorf("expected error evaluating query %q (line %d) but got none", cmd.expr, cmd.line)
 		}
 
-		err = cmd.compareResult(res.Value)
+		err = cmd.compareResult(res.parser.Value)
 		if err != nil {
 			return errors.Wrapf(err, "error in %s %s", cmd, cmd.expr)
 		}
@@ -478,7 +479,7 @@ func (t *Test) exec(tc testCommand) error {
 			// Ordering isn't defined for range queries.
 			return nil
 		}
-		mat := rangeRes.Value.(Matrix)
+		mat := rangeRes.parser.Value.(Matrix)
 		vec := make(Vector, 0, len(mat))
 		for _, series := range mat {
 			for _, point := range series.Points {
@@ -488,7 +489,7 @@ func (t *Test) exec(tc testCommand) error {
 				}
 			}
 		}
-		if _, ok := res.Value.(Scalar); ok {
+		if _, ok := res.parser.Value.(Scalar); ok {
 			err = cmd.compareResult(Scalar{V: vec[0].Point.V})
 		} else {
 			err = cmd.compareResult(vec)
diff --git a/promql/test_test.go b/promql/test_test.go
index f03f6d2037..6328dc76ad 100644
--- a/promql/test_test.go
+++ b/promql/test_test.go
@@ -127,7 +127,7 @@ func TestLazyLoader_WithSamplesTill(t *testing.T) {
 				for _, s := range tc.series {
 					var matchers []*labels.Matcher
 					for _, label := range s.Metric {
-						m, err := labels.NewMatcher(labels.MatchEqual, label.Name, label.Value)
+						m, err := labels.NewMatcher(labels.MatchEqual, label.Name, label.parser.Value)
 						testutil.Ok(t, err)
 						matchers = append(matchers, m)
 					}