From f0e849bdd74b5a1667a9c4074f10aeed4a0dc067 Mon Sep 17 00:00:00 2001
From: jonmcquillan <jon.mcquillan@hpe.com>
Date: Fri, 1 Sep 2023 09:05:57 -0600
Subject: [PATCH] Update to github actions and cargo fmt (#5)

---
 .circleci/config.yml          |  49 --
 .github/dependabot.yml        |  18 +-
 .github/workflows/release.yml |  27 +
 .github/workflows/test.yml    |  22 +
 Cargo.toml                    |   5 +-
 README.md                     |   3 +-
 examples/label_drop.rs        |  76 +--
 examples/label_passthrough.rs |  26 +-
 examples/parse.rs             |  20 +-
 examples/reformat.rs          |  20 +-
 examples/return_value.rs      |  20 +-
 src/lib.rs                    |   5 +-
 src/parser.rs                 | 803 +++++++++++++++---------------
 src/types/expression.rs       | 180 +++----
 src/types/function.rs         | 594 +++++++++++-----------
 src/types/group.rs            |  95 ++--
 src/types/misc.rs             | 178 +++----
 src/types/operator.rs         | 616 ++++++++++++-----------
 src/types/return_value.rs     | 315 ++++++------
 src/types/selector.rs         | 412 ++++++++--------
 tests/label_passthrough.rs    | 292 ++++++-----
 tests/simple.rs               | 906 ++++++++++++++++++----------------
 tests/subquery.rs             | 294 +++++------
 23 files changed, 2536 insertions(+), 2440 deletions(-)
 delete mode 100644 .circleci/config.yml
 create mode 100644 .github/workflows/release.yml
 create mode 100644 .github/workflows/test.yml

diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index 0c60028..0000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,49 +0,0 @@
-version: 2.1
-
-jobs:
-  test:
-    docker:
-      - image: rust:1.56-slim-buster
-    steps:
-      - checkout
-      - run:
-          name: patch crate version
-          command: |
-            if [[ -n "$CIRCLE_TAG" ]]; then
-              version=$(echo "$CIRCLE_TAG" | sed -e 's/^v//')
-              sed -i -e "s/version = \"0.1.0\"/version = \"$version\"/" Cargo.toml
-            fi
-      - run:
-          name: cargo test
-          command: cargo test
-
-  publish:
-    docker:
-      - image: rust:1.56-slim-buster
-    steps:
-      - checkout
-      - run:
-          name: patch crate version
-          command: |
-            version=$(echo "$CIRCLE_TAG" | sed -e 's/^v//')
-            sed -i -e "s/version = \"0.1.0\"/version = \"$version\"/" Cargo.toml
-      - run:
-          name: cargo publish
-          command: cargo publish --allow-dirty --locked
-
-workflows:
-  version: 2
-  build-and-publish:
-    jobs:
-      - test:
-          filters:
-            tags:
-              only: /.*/
-      - publish:
-          requires:
-            - test
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /.*/
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 2f3bc79..834f422 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,8 +1,14 @@
 version: 2
 updates:
-- package-ecosystem: cargo
-  open-pull-requests-limit: 25
-  directory: /
-  registries: []
-  schedule:
-    interval: daily
+  - package-ecosystem: cargo
+    open-pull-requests-limit: 25
+    directory: /
+    registries: []
+    schedule:
+      interval: daily
+  - package-ecosystem: github-actions
+    directory: /
+    registries: []
+    schedule:
+      interval: daily
+
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..8b13679
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,27 @@
+# (c) Copyright 2023 Hewlett Packard Enterprise Development LP
+
+name: Release
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  upload_artifacts:
+    runs-on: ubuntu-latest
+    env:
+      CARGO_TERM_COLOR: always
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744
+      - name: Update Tag
+        shell: bash
+        run: |
+          version=$(echo "$GITHUB_REF" | sed -e 's/^v//')
+          sed -i -e "s/version = \"0.1.0\"/version = \"$version\"/" Cargo.toml
+      - name: Publish
+        run: cargo publish --allow-dirty --locked
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..279c791
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,22 @@
+# (c) Copyright 2023 Hewlett Packard Enterprise Development LP
+
+name: Rust Checks
+
+on:
+  pull_request:
+
+jobs:
+  build:
+    name: Rust Checks
+    runs-on: ubuntu-latest
+    env:
+      CARGO_TERM_COLOR: always
+    steps:
+      - name: Checkout
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744
+      - name: Rust Format
+        run: cargo fmt --check
+      - name: Clippy
+        run: cargo clippy
+      - name: Test
+        run: cargo test --verbose
diff --git a/Cargo.toml b/Cargo.toml
index 320dfd1..cc617a0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,16 +7,13 @@ license = "MIT"
 keywords = ["parser", "prometheus", "pest"]
 homepage = "https://github.com/HewlettPackard/prometheus-parser-rs/"
 repository = "https://github.com/HewlettPackard/prometheus-parser-rs/"
-exclude = [".circleci/**/*"]
+exclude = [".github/**/*"]
 readme = "README.md"
 
 # NOTE: do not change the version here, it will be replaced with the git tag
 # version by CI
 version = "0.1.0"
 
-[badges]
-circle-ci = { repository = "HewlettPackard/prometheus-parser-rs", branch = "master" }
-
 [dependencies]
 pest = "2.1"
 pest_consume = "1.1"
diff --git a/README.md b/README.md
index 0513568..ff8ee17 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,5 @@
 # prometheus-parser-rs
 
-[![CircleCI](https://circleci.com/gh/HewlettPackard/prometheus-parser-rs.svg?style=svg)](https://circleci.com/gh/HewlettPackard/prometheus-parser-rs)
 [![docs.rs](https://docs.rs/prometheus-parser/badge.svg)](https://docs.rs/prometheus-parser/)
 
 prometheus-parser parses arbitrary Prometheus expressions into a syntax tree
@@ -225,7 +224,7 @@ though the [code of conduct] for some pointers to get started.
 
 Note that - as mentioned in the code of conduct - code contributions must
 indicate that you accept the [Developer Certificate of Origin][dco],
-essentially asserting you have the necessary rights to submit the code you're 
+essentially asserting you have the necessary rights to submit the code you're
 contributing under the project's license (MIT). If you agree, simply pass `-s`
 to `git commit`:
 
diff --git a/examples/label_drop.rs b/examples/label_drop.rs
index 4df2add..56f9595 100644
--- a/examples/label_drop.rs
+++ b/examples/label_drop.rs
@@ -7,43 +7,43 @@ use prometheus_parser;
 use prometheus_parser::ReturnKind;
 
 fn main() {
-  let args: Vec<String> = env::args().collect();
-
-  let expr = &args[1];
-  let label = &args[2];
-  let res = prometheus_parser::parse_expr(expr);
-
-  match res {
-    Ok(r) => {
-      let return_value = r.return_value();
-
-      if let ReturnKind::Unknown(cause) = &return_value.kind {
-        println!("note: expression return type is unknown, result may be inaccurate");
-        println!("  reason:     {}", cause.message);
-        println!("  expression: {}", cause.expression);
-        println!();
-      }
-
-      if let Some(drops) = return_value.drops(label) {
-        println!("label '{}' is dropped:\n", label);
-
-        if let Some(span) = drops.span {
-          println!("{}", expr);
-          println!(
-            "{}{}",
-            " ".repeat(span.start),
-            "-".repeat(span.end - span.start)
-          );
+    let args: Vec<String> = env::args().collect();
+
+    let expr = &args[1];
+    let label = &args[2];
+    let res = prometheus_parser::parse_expr(expr);
+
+    match res {
+        Ok(r) => {
+            let return_value = r.return_value();
+
+            if let ReturnKind::Unknown(cause) = &return_value.kind {
+                println!("note: expression return type is unknown, result may be inaccurate");
+                println!("  reason:     {}", cause.message);
+                println!("  expression: {}", cause.expression);
+                println!();
+            }
+
+            if let Some(drops) = return_value.drops(label) {
+                println!("label '{}' is dropped:\n", label);
+
+                if let Some(span) = drops.span {
+                    println!("{}", expr);
+                    println!(
+                        "{}{}",
+                        " ".repeat(span.start),
+                        "-".repeat(span.end - span.start)
+                    );
+                }
+
+                println!();
+                println!("parent expression: {}", drops.expression);
+            } else {
+                println!("label '{}' is not dropped", label);
+            }
         }
-
-        println!();
-        println!("parent expression: {}", drops.expression);
-      } else {
-        println!("label '{}' is not dropped", label);
-      }
-    },
-    Err(e) => {
-      eprintln!("error: {}", e);
-    }
-  };
+        Err(e) => {
+            eprintln!("error: {}", e);
+        }
+    };
 }
diff --git a/examples/label_passthrough.rs b/examples/label_passthrough.rs
index 87c6db1..ffc645d 100644
--- a/examples/label_passthrough.rs
+++ b/examples/label_passthrough.rs
@@ -5,19 +5,19 @@ use std::env;
 use prometheus_parser;
 
 fn main() {
-  let args: Vec<String> = env::args().collect();
+    let args: Vec<String> = env::args().collect();
 
-  let expr = &args[1];
-  let labels: Vec<&str> = args[2..].iter().map(|s| s.as_str()).collect();
-  let res = prometheus_parser::parse_expr(expr);
+    let expr = &args[1];
+    let labels: Vec<&str> = args[2..].iter().map(|s| s.as_str()).collect();
+    let res = prometheus_parser::parse_expr(expr);
 
-  match res {
-    Ok(r) => {
-      let return_value = r.return_value();
-      println!("{:#?}", return_value.passthrough(&labels));
-    },
-    Err(e) => {
-      eprintln!("error: {}", e);
-    }
-  };
+    match res {
+        Ok(r) => {
+            let return_value = r.return_value();
+            println!("{:#?}", return_value.passthrough(&labels));
+        }
+        Err(e) => {
+            eprintln!("error: {}", e);
+        }
+    };
 }
diff --git a/examples/parse.rs b/examples/parse.rs
index b437f4b..218ec9c 100644
--- a/examples/parse.rs
+++ b/examples/parse.rs
@@ -5,15 +5,15 @@ use std::env;
 use prometheus_parser;
 
 fn main() {
-  let args: Vec<String> = env::args().collect();
-  let res = prometheus_parser::parse_expr(&args[1]);
+    let args: Vec<String> = env::args().collect();
+    let res = prometheus_parser::parse_expr(&args[1]);
 
-  match res {
-    Ok(r) => {
-      println!("{:#?}", r);
-    },
-    Err(e) => {
-      eprintln!("error: {}", e);
-    }
-  };
+    match res {
+        Ok(r) => {
+            println!("{:#?}", r);
+        }
+        Err(e) => {
+            eprintln!("error: {}", e);
+        }
+    };
 }
diff --git a/examples/reformat.rs b/examples/reformat.rs
index e518df6..6ca38a3 100644
--- a/examples/reformat.rs
+++ b/examples/reformat.rs
@@ -5,15 +5,15 @@ use std::env;
 use prometheus_parser;
 
 fn main() {
-  let args: Vec<String> = env::args().collect();
-  let res = prometheus_parser::parse_expr(&args[1]);
+    let args: Vec<String> = env::args().collect();
+    let res = prometheus_parser::parse_expr(&args[1]);
 
-  match res {
-    Ok(r) => {
-      println!("{}", r);
-    },
-    Err(e) => {
-      eprintln!("error: {}", e);
-    }
-  };
+    match res {
+        Ok(r) => {
+            println!("{}", r);
+        }
+        Err(e) => {
+            eprintln!("error: {}", e);
+        }
+    };
 }
diff --git a/examples/return_value.rs b/examples/return_value.rs
index 5db91cd..4705b60 100644
--- a/examples/return_value.rs
+++ b/examples/return_value.rs
@@ -5,15 +5,15 @@ use std::env;
 use prometheus_parser;
 
 fn main() {
-  let args: Vec<String> = env::args().collect();
-  let res = prometheus_parser::parse_expr(&args[1]);
+    let args: Vec<String> = env::args().collect();
+    let res = prometheus_parser::parse_expr(&args[1]);
 
-  match res {
-    Ok(r) => {
-      println!("{:#?}", r.return_value());
-    },
-    Err(e) => {
-      eprintln!("error: {}", e);
-    }
-  };
+    match res {
+        Ok(r) => {
+            println!("{:#?}", r.return_value());
+        }
+        Err(e) => {
+            eprintln!("error: {}", e);
+        }
+    };
 }
diff --git a/src/lib.rs b/src/lib.rs
index 0b594d0..10c79fd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,9 @@
-
 // (C) Copyright 2019-2020 Hewlett Packard Enterprise Development LP
 
 #![forbid(unsafe_code)]
 
-mod types;
 mod parser;
+mod types;
 
-pub use types::*;
 pub use parser::{parse_expr, Result};
+pub use types::*;
diff --git a/src/parser.rs b/src/parser.rs
index cadbfcb..bcb1be0 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -2,11 +2,11 @@
 
 use std::f64;
 
+use enquote::unquote;
 use lazy_static::lazy_static;
 use pest::prec_climber as pcl;
 use pest::prec_climber::PrecClimber;
 use pest_consume::{match_nodes, Error, Parser};
-use enquote::unquote;
 
 use crate::types::*;
 
@@ -14,37 +14,35 @@ pub type Result<T> = std::result::Result<T, Error<Rule>>;
 pub(crate) type Node<'i> = pest_consume::Node<'i, Rule, ()>;
 
 lazy_static! {
-  static ref PRECCLIMBER: PrecClimber<Rule> = PrecClimber::new(
-    vec![
-      pcl::Operator::new(Rule::op_or, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_unless, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_and, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_greater_than, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_greater_than_equal, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_less_than, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_less_than_equal, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_not_equal, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_equal, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_subtract, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_add, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_modulo, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_divide, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_multiply, pcl::Assoc::Left),
-      pcl::Operator::new(Rule::op_power, pcl::Assoc::Right)
-    ]
-  );
+    static ref PRECCLIMBER: PrecClimber<Rule> = PrecClimber::new(vec![
+        pcl::Operator::new(Rule::op_or, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_unless, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_and, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_greater_than, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_greater_than_equal, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_less_than, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_less_than_equal, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_not_equal, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_equal, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_subtract, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_add, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_modulo, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_divide, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_multiply, pcl::Assoc::Left),
+        pcl::Operator::new(Rule::op_power, pcl::Assoc::Right)
+    ]);
 }
 
 /// An intermediate struct for selectors with a named metric.
 /// Label-only selectors may evaluate immediately to a Selector
 struct MetricSelectorIntermediate {
-  metric: String,
-  labels: Vec<Label>
+    metric: String,
+    labels: Vec<Label>,
 }
 
 struct MatchingIntermediate {
-  op: MatchingOp,
-  labels: Vec<String>
+    op: MatchingOp,
+    labels: Vec<String>,
 }
 
 #[derive(Parser)]
@@ -54,394 +52,389 @@ struct PrometheusParser;
 #[allow(clippy::int_plus_one)]
 #[pest_consume::parser]
 impl PrometheusParser {
-  fn EOI(_input: Node) -> Result<()> {
-    Ok(())
-  }
-
-  fn signed_float(input: Node) -> Result<Expression> {
-    let val = match input.as_str().trim() {
-      "Inf" | "+Inf" => f64::INFINITY,
-      "-Inf" => f64::NEG_INFINITY,
-      "NaN" | "+NaN" | "-NaN" => f64::NAN,
-      f => f.parse().map_err(|e| input.error(e))?
-    };
-
-    Ok(Expression::Float(val))
-  }
-
-  fn string(input: Node) -> Result<Expression> {
-    let s = unquote(input.as_str()).map_err(|e| input.error(e))?;
-
-    Ok(Expression::String(s))
-  }
-
-  fn label_key(input: Node) -> Result<String> {
-    Ok(input.as_str().trim().to_string())
-  }
-
-  fn label_value(input: Node) -> Result<String> {
-    unquote(input.as_str()).map_err(|e| input.error(e))
-  }
-
-  fn group(input: Node) -> Result<Expression> {
-    let span = Span::from_node(&input);
-    Ok(match_nodes!(input.into_children();
-      [expression(e)] => Group::new(e).span(span).wrap(),
-      [expression(e), subquery(s)] => Group::new(e)
-        .subquery(s)
-        .span(span)
-        .wrap()
-    ))
-  }
-
-  fn selector_metric(input: Node) -> Result<String> {
-    Ok(input.as_str().trim().to_string())
-  }
-
-  fn label_op_equal(_input: Node) -> Result<LabelOp> {
-    Ok(LabelOp::Equal)
-  }
-
-  fn label_op_not_equal(_input: Node) -> Result<LabelOp> {
-    Ok(LabelOp::NotEqual)
-  }
-
-  fn label_op_regex_equal(_input: Node) -> Result<LabelOp> {
-    Ok(LabelOp::RegexEqual)
-  }
-
-  fn label_op_regex_not_equal(_input: Node) -> Result<LabelOp> {
-    Ok(LabelOp::RegexNotEqual)
-  }
-
-  fn label_operator(input: Node) -> Result<LabelOp> {
-    Ok(match_nodes!(input.into_children();
-      [label_op_equal(op)] => op,
-      [label_op_not_equal(op)] => op,
-      [label_op_regex_equal(op)] => op,
-      [label_op_regex_not_equal(op)] => op,
-    ))
-  }
-
-  fn label(input: Node) -> Result<Label> {
-    let span = Some(Span::from_node(&input));
-    Ok(match_nodes!(input.into_children();
-      [label_key(key), label_operator(op), label_value(value)] => Label {
-        op, key, value, span
-      }
-    ))
-  }
-
-  fn selector_label(input: Node) -> Result<Vec<Label>> {
-    Ok(match_nodes!(input.into_children();
-      [label(l)..] => l.collect()
-    ))
-  }
-
-  fn duration_value(input: Node) -> Result<u64> {
-    Ok(input.as_str().trim().parse().map_err(|e| input.error(e))?)
-  }
-
-  fn duration_unit(input: Node) -> Result<String> {
-    Ok(input.as_str().trim().to_string())
-  }
-
-  fn subquery_duration(input: Node) -> Result<PromDuration> {
-    Ok(match_nodes!(input.children();
-      [duration_value(val), duration_unit(unit)] => {
-        PromDuration::from_pair(&unit, val).map_err(|e| input.error(e))?
-      }
-    ))
-  }
-
-  fn subquery(input: Node) -> Result<Subquery> {
-    let span = Some(Span::from_node(&input));
-    Ok(match_nodes!(input.children();
-      [subquery_duration(range)] => Subquery {
-        range, resolution: None, span
-      },
-      [subquery_duration(range), subquery_duration(resolution)] => Subquery {
-        range, resolution: Some(resolution), span
-      }
-    ))
-  }
-
-  fn selector_range(input: Node) -> Result<PromDuration> {
-    Ok(match_nodes!(input.children();
-      [duration_value(val), duration_unit(unit)] => {
-        PromDuration::from_pair(&unit, val).map_err(|e| input.error(e))?
-      }
-    ))
-  }
-
-  fn offset(input: Node) -> Result<PromDuration> {
-    Ok(match_nodes!(input.children();
-      [duration_value(val), duration_unit(unit)] => {
-        PromDuration::from_pair(&unit, val).map_err(|e| input.error(e))?
-      }
-    ))
-  }
-
-  fn metric_selector(input: Node) -> Result<MetricSelectorIntermediate> {
-    Ok(match_nodes!(input.into_children();
-      [selector_metric(metric)] => MetricSelectorIntermediate {
-        metric, labels: vec![]
-      },
-      [selector_metric(metric), selector_label(labels)] => {
-        MetricSelectorIntermediate {
-          metric, labels
+    fn EOI(_input: Node) -> Result<()> {
+        Ok(())
+    }
+
+    fn signed_float(input: Node) -> Result<Expression> {
+        let val = match input.as_str().trim() {
+            "Inf" | "+Inf" => f64::INFINITY,
+            "-Inf" => f64::NEG_INFINITY,
+            "NaN" | "+NaN" | "-NaN" => f64::NAN,
+            f => f.parse().map_err(|e| input.error(e))?,
+        };
+
+        Ok(Expression::Float(val))
+    }
+
+    fn string(input: Node) -> Result<Expression> {
+        let s = unquote(input.as_str()).map_err(|e| input.error(e))?;
+
+        Ok(Expression::String(s))
+    }
+
+    fn label_key(input: Node) -> Result<String> {
+        Ok(input.as_str().trim().to_string())
+    }
+
+    fn label_value(input: Node) -> Result<String> {
+        unquote(input.as_str()).map_err(|e| input.error(e))
+    }
+
+    fn group(input: Node) -> Result<Expression> {
+        let span = Span::from_node(&input);
+        Ok(match_nodes!(input.into_children();
+          [expression(e)] => Group::new(e).span(span).wrap(),
+          [expression(e), subquery(s)] => Group::new(e)
+            .subquery(s)
+            .span(span)
+            .wrap()
+        ))
+    }
+
+    fn selector_metric(input: Node) -> Result<String> {
+        Ok(input.as_str().trim().to_string())
+    }
+
+    fn label_op_equal(_input: Node) -> Result<LabelOp> {
+        Ok(LabelOp::Equal)
+    }
+
+    fn label_op_not_equal(_input: Node) -> Result<LabelOp> {
+        Ok(LabelOp::NotEqual)
+    }
+
+    fn label_op_regex_equal(_input: Node) -> Result<LabelOp> {
+        Ok(LabelOp::RegexEqual)
+    }
+
+    fn label_op_regex_not_equal(_input: Node) -> Result<LabelOp> {
+        Ok(LabelOp::RegexNotEqual)
+    }
+
+    fn label_operator(input: Node) -> Result<LabelOp> {
+        Ok(match_nodes!(input.into_children();
+          [label_op_equal(op)] => op,
+          [label_op_not_equal(op)] => op,
+          [label_op_regex_equal(op)] => op,
+          [label_op_regex_not_equal(op)] => op,
+        ))
+    }
+
+    fn label(input: Node) -> Result<Label> {
+        let span = Some(Span::from_node(&input));
+        Ok(match_nodes!(input.into_children();
+          [label_key(key), label_operator(op), label_value(value)] => Label {
+            op, key, value, span
+          }
+        ))
+    }
+
+    fn selector_label(input: Node) -> Result<Vec<Label>> {
+        Ok(match_nodes!(input.into_children();
+          [label(l)..] => l.collect()
+        ))
+    }
+
+    fn duration_value(input: Node) -> Result<u64> {
+        Ok(input.as_str().trim().parse().map_err(|e| input.error(e))?)
+    }
+
+    fn duration_unit(input: Node) -> Result<String> {
+        Ok(input.as_str().trim().to_string())
+    }
+
+    fn subquery_duration(input: Node) -> Result<PromDuration> {
+        Ok(match_nodes!(input.children();
+          [duration_value(val), duration_unit(unit)] => {
+            PromDuration::from_pair(&unit, val).map_err(|e| input.error(e))?
+          }
+        ))
+    }
+
+    fn subquery(input: Node) -> Result<Subquery> {
+        let span = Some(Span::from_node(&input));
+        Ok(match_nodes!(input.children();
+          [subquery_duration(range)] => Subquery {
+            range, resolution: None, span
+          },
+          [subquery_duration(range), subquery_duration(resolution)] => Subquery {
+            range, resolution: Some(resolution), span
+          }
+        ))
+    }
+
+    fn selector_range(input: Node) -> Result<PromDuration> {
+        Ok(match_nodes!(input.children();
+          [duration_value(val), duration_unit(unit)] => {
+            PromDuration::from_pair(&unit, val).map_err(|e| input.error(e))?
+          }
+        ))
+    }
+
+    fn offset(input: Node) -> Result<PromDuration> {
+        Ok(match_nodes!(input.children();
+          [duration_value(val), duration_unit(unit)] => {
+            PromDuration::from_pair(&unit, val).map_err(|e| input.error(e))?
+          }
+        ))
+    }
+
+    fn metric_selector(input: Node) -> Result<MetricSelectorIntermediate> {
+        Ok(match_nodes!(input.into_children();
+          [selector_metric(metric)] => MetricSelectorIntermediate {
+            metric, labels: vec![]
+          },
+          [selector_metric(metric), selector_label(labels)] => {
+            MetricSelectorIntermediate {
+              metric, labels
+            }
+          }
+        ))
+    }
+
+    fn selector(input: Node) -> Result<Expression> {
+        let span = Some(Span::from_node(&input));
+
+        let mut metric = None;
+        let mut labels = None;
+        let mut range = None;
+        let mut offset = None;
+        let mut subquery = None;
+
+        for child in input.into_children() {
+            match child.as_rule() {
+                Rule::metric_selector => {
+                    let intermediate = PrometheusParser::metric_selector(child)?;
+                    metric = Some(intermediate.metric);
+                    labels = Some(intermediate.labels);
+                }
+                Rule::selector_label => {
+                    labels = Some(PrometheusParser::selector_label(child)?);
+                }
+                Rule::selector_range => {
+                    range = Some(PrometheusParser::selector_range(child)?);
+                }
+                Rule::offset => {
+                    offset = Some(PrometheusParser::offset(child)?);
+                }
+                Rule::subquery => {
+                    subquery = Some(PrometheusParser::subquery(child)?);
+                }
+                r => return Err(child.error(format!("invalid rule {:?} in selector", r))),
+            }
         }
-      }
-    ))
-  }
-
-  fn selector(input: Node) -> Result<Expression> {
-    let span = Some(Span::from_node(&input));
-
-    let mut metric = None;
-    let mut labels = None;
-    let mut range = None;
-    let mut offset = None;
-    let mut subquery = None;
-
-    for child in input.into_children() {
-      match child.as_rule() {
-        Rule::metric_selector => {
-          let intermediate = PrometheusParser::metric_selector(child)?;
-          metric = Some(intermediate.metric);
-          labels = Some(intermediate.labels);
-        },
-        Rule::selector_label => {
-          labels = Some(PrometheusParser::selector_label(child)?);
-        },
-        Rule::selector_range => {
-          range = Some(PrometheusParser::selector_range(child)?);
-        },
-        Rule::offset => {
-          offset = Some(PrometheusParser::offset(child)?);
-        },
-        Rule::subquery => {
-          subquery = Some(PrometheusParser::subquery(child)?);
-        },
-        r => return Err(child.error(format!(
-          "invalid rule {:?} in selector", r
-        )))
-      }
-    }
-
-    let labels = labels.unwrap_or_else(|| vec![]);
-
-    Ok(Expression::Selector(Selector {
-      metric,
-      labels,
-      range,
-      offset,
-      subquery,
-      span
-    }))
-  }
-
-  fn function_name(input: Node) -> Result<String> {
-    Ok(input.as_str().trim().to_string())
-  }
-
-  fn function_agg_op_by(_input: Node) -> Result<AggregationOp> {
-    Ok(AggregationOp::By)
-  }
-
-  fn function_agg_op_without(_input: Node) -> Result<AggregationOp> {
-    Ok(AggregationOp::Without)
-  }
-
-  fn function_agg_op(input: Node) -> Result<AggregationOp> {
-    Ok(match_nodes!(input.into_children();
-      [function_agg_op_by(o)] => o,
-      [function_agg_op_without(o)] => o
-    ))
-  }
-
-  fn function_agg(input: Node) -> Result<Aggregation> {
-    let span = Some(Span::from_node(&input));
-
-    Ok(match_nodes!(input.into_children();
-      [function_agg_op(op), label_key(labels)..] => Aggregation {
-        op,
-        labels: labels.collect(),
-        span
-      }
-    ))
-  }
-
-  fn function(input: Node) -> Result<Expression> {
-    let span = Some(Span::from_node(&input));
-
-    let mut name = None;
-    let mut args = Vec::new();
-    let mut aggregation = None;
-    let mut subquery = None;
-
-    // match_nodes gets unruly with optional aggregations (2 forms) and
-    // subqueries, so break out into a manual conversion
-    for child in input.children() {
-      match child.as_rule() {
-        Rule::function_name => name = Some(PrometheusParser::function_name(child)?),
-        Rule::expression => args.push(Box::new(PrometheusParser::expression(child)?)),
-        Rule::function_agg => aggregation = Some(PrometheusParser::function_agg(child)?),
-        Rule::subquery => subquery = Some(PrometheusParser::subquery(child)?),
-        r => return Err(child.error(format!(
-          "invalid rule {:?} in function", r
-        )))
-      }
-    }
-
-    let name = match name {
-      Some(name) => name,
-      None => return Err(input.error("function name is required"))
-    };
-    
-    Ok(Expression::Function(Function {
-      name,
-      args,
-      aggregation,
-      subquery,
-      span
-    }))
-  }
-
-  fn matching_on(_input: Node) -> Result<MatchingOp> {
-    Ok(MatchingOp::On)
-  }
-
-  fn matching_ignoring(_input: Node) -> Result<MatchingOp> {
-    Ok(MatchingOp::Ignoring)
-  }
-
-  fn matching(input: Node) -> Result<MatchingIntermediate> {
-    Ok(match_nodes!(input.into_children();
-      [matching_on(op), label_key(labels)..] => MatchingIntermediate {
-        op, labels: labels.collect()
-      },
-      [matching_ignoring(op), label_key(labels)..] => MatchingIntermediate {
-        op, labels: labels.collect()
-      }
-    ))
-  }
-
-  fn matching_group_left(_input: Node) -> Result<MatchingGroupOp> {
-    Ok(MatchingGroupOp::Left)
-  }
-
-  fn matching_group_right(_input: Node) -> Result<MatchingGroupOp> {
-    Ok(MatchingGroupOp::Right)
-  }
-
-  fn matching_group(input: Node) -> Result<MatchingGroup> {
-    let span = Some(Span::from_node(&input));
-
-    Ok(match_nodes!(input.into_children();
-      [matching_group_left(op), label_key(labels)..] => MatchingGroup {
-        op, labels: labels.collect(), span
-      },
-      [matching_group_right(op), label_key(labels)..] => MatchingGroup {
-        op, labels: labels.collect(), span
-      }
-    ))
-  }
-
-  fn matching_expression(input: Node) -> Result<Matching> {
-    let span = Some(Span::from_node(&input));
-
-    Ok(match_nodes!(input.into_children();
-      [matching(m)] => Matching {
-        op: m.op,
-        labels: m.labels,
-
-        group: None,
-
-        span
-      },
-      [matching(m), matching_group(g)] => Matching {
-        op: m.op,
-        labels: m.labels,
-
-        group: Some(g),
-
-        span
-      }
-    ))
-  }
-
-  #[prec_climb(expression_term, PRECCLIMBER)]
-  fn expression(lhs: Expression, op: Node, rhs: Expression) -> Result<Expression> {
-    let span = Some(Span::from_node(&op));
-
-    use Rule::*;
-    let kind = match op.as_rule() {
-      op_or => OperatorKind::Or,
-      op_unless => OperatorKind::Unless,
-      op_and => OperatorKind::And,
-      op_greater_than => OperatorKind::GreaterThan,
-      op_greater_than_equal => OperatorKind::GreaterThanEqual,
-      op_less_than => OperatorKind::LessThan,
-      op_less_than_equal => OperatorKind::LessThanEqual,
-      op_not_equal => OperatorKind::NotEqual,
-      op_equal => OperatorKind::Equal,
-      op_subtract => OperatorKind::Subtract,
-      op_add => OperatorKind::Add,
-      op_modulo => OperatorKind::Modulo,
-      op_divide => OperatorKind::Divide,
-      op_multiply => OperatorKind::Multiply,
-      op_power => OperatorKind::Power,
-      r => return Err(op.error(format!("rule {:?} isn't an operator", r)))
-    };
-
-    // gotta break out of pest_consume slightly for this...
-    let mut matching_clause = None;
-    for child in op.into_children() {
-      if let Rule::matching_expression = child.as_rule() {
-        matching_clause = Some(PrometheusParser::matching_expression(child)?);
-        break;
-      }
-    }
-
-    Ok(Expression::Operator(Operator {
-      kind,
-      lhs: Box::new(lhs),
-      rhs: Box::new(rhs),
-
-      matching: matching_clause,
-
-      span
-    }))
-  }
-
-  fn expression_term(input: Node) -> Result<Expression> {
-    Ok(match_nodes!(input.into_children();
-      [signed_float(f)] => f,
-      [string(s)] => s,
-      [group(g)] => g,
-      [function(f)] => f,
-      [selector(s)] => s
-    ))
-  }
-
-  fn prometheus(input: Node) -> Result<Expression> {
-    Ok(match_nodes!(input.into_children();
-      [expression(e), EOI(_)] => e,
-    ))
-  }
 
+        let labels = labels.unwrap_or_else(|| vec![]);
+
+        Ok(Expression::Selector(Selector {
+            metric,
+            labels,
+            range,
+            offset,
+            subquery,
+            span,
+        }))
+    }
+
+    fn function_name(input: Node) -> Result<String> {
+        Ok(input.as_str().trim().to_string())
+    }
+
+    fn function_agg_op_by(_input: Node) -> Result<AggregationOp> {
+        Ok(AggregationOp::By)
+    }
+
+    fn function_agg_op_without(_input: Node) -> Result<AggregationOp> {
+        Ok(AggregationOp::Without)
+    }
+
+    fn function_agg_op(input: Node) -> Result<AggregationOp> {
+        Ok(match_nodes!(input.into_children();
+          [function_agg_op_by(o)] => o,
+          [function_agg_op_without(o)] => o
+        ))
+    }
+
+    fn function_agg(input: Node) -> Result<Aggregation> {
+        let span = Some(Span::from_node(&input));
+
+        Ok(match_nodes!(input.into_children();
+          [function_agg_op(op), label_key(labels)..] => Aggregation {
+            op,
+            labels: labels.collect(),
+            span
+          }
+        ))
+    }
+
+    fn function(input: Node) -> Result<Expression> {
+        let span = Some(Span::from_node(&input));
+
+        let mut name = None;
+        let mut args = Vec::new();
+        let mut aggregation = None;
+        let mut subquery = None;
+
+        // match_nodes gets unruly with optional aggregations (2 forms) and
+        // subqueries, so break out into a manual conversion
+        for child in input.children() {
+            match child.as_rule() {
+                Rule::function_name => name = Some(PrometheusParser::function_name(child)?),
+                Rule::expression => args.push(Box::new(PrometheusParser::expression(child)?)),
+                Rule::function_agg => aggregation = Some(PrometheusParser::function_agg(child)?),
+                Rule::subquery => subquery = Some(PrometheusParser::subquery(child)?),
+                r => return Err(child.error(format!("invalid rule {:?} in function", r))),
+            }
+        }
+
+        let name = match name {
+            Some(name) => name,
+            None => return Err(input.error("function name is required")),
+        };
+
+        Ok(Expression::Function(Function {
+            name,
+            args,
+            aggregation,
+            subquery,
+            span,
+        }))
+    }
+
+    fn matching_on(_input: Node) -> Result<MatchingOp> {
+        Ok(MatchingOp::On)
+    }
+
+    fn matching_ignoring(_input: Node) -> Result<MatchingOp> {
+        Ok(MatchingOp::Ignoring)
+    }
+
+    fn matching(input: Node) -> Result<MatchingIntermediate> {
+        Ok(match_nodes!(input.into_children();
+          [matching_on(op), label_key(labels)..] => MatchingIntermediate {
+            op, labels: labels.collect()
+          },
+          [matching_ignoring(op), label_key(labels)..] => MatchingIntermediate {
+            op, labels: labels.collect()
+          }
+        ))
+    }
+
+    fn matching_group_left(_input: Node) -> Result<MatchingGroupOp> {
+        Ok(MatchingGroupOp::Left)
+    }
+
+    fn matching_group_right(_input: Node) -> Result<MatchingGroupOp> {
+        Ok(MatchingGroupOp::Right)
+    }
+
+    fn matching_group(input: Node) -> Result<MatchingGroup> {
+        let span = Some(Span::from_node(&input));
+
+        Ok(match_nodes!(input.into_children();
+          [matching_group_left(op), label_key(labels)..] => MatchingGroup {
+            op, labels: labels.collect(), span
+          },
+          [matching_group_right(op), label_key(labels)..] => MatchingGroup {
+            op, labels: labels.collect(), span
+          }
+        ))
+    }
+
+    fn matching_expression(input: Node) -> Result<Matching> {
+        let span = Some(Span::from_node(&input));
+
+        Ok(match_nodes!(input.into_children();
+          [matching(m)] => Matching {
+            op: m.op,
+            labels: m.labels,
+
+            group: None,
+
+            span
+          },
+          [matching(m), matching_group(g)] => Matching {
+            op: m.op,
+            labels: m.labels,
+
+            group: Some(g),
+
+            span
+          }
+        ))
+    }
+
+    #[prec_climb(expression_term, PRECCLIMBER)]
+    fn expression(lhs: Expression, op: Node, rhs: Expression) -> Result<Expression> {
+        let span = Some(Span::from_node(&op));
+
+        use Rule::*;
+        let kind = match op.as_rule() {
+            op_or => OperatorKind::Or,
+            op_unless => OperatorKind::Unless,
+            op_and => OperatorKind::And,
+            op_greater_than => OperatorKind::GreaterThan,
+            op_greater_than_equal => OperatorKind::GreaterThanEqual,
+            op_less_than => OperatorKind::LessThan,
+            op_less_than_equal => OperatorKind::LessThanEqual,
+            op_not_equal => OperatorKind::NotEqual,
+            op_equal => OperatorKind::Equal,
+            op_subtract => OperatorKind::Subtract,
+            op_add => OperatorKind::Add,
+            op_modulo => OperatorKind::Modulo,
+            op_divide => OperatorKind::Divide,
+            op_multiply => OperatorKind::Multiply,
+            op_power => OperatorKind::Power,
+            r => return Err(op.error(format!("rule {:?} isn't an operator", r))),
+        };
+
+        // gotta break out of pest_consume slightly for this...
+        let mut matching_clause = None;
+        for child in op.into_children() {
+            if let Rule::matching_expression = child.as_rule() {
+                matching_clause = Some(PrometheusParser::matching_expression(child)?);
+                break;
+            }
+        }
+
+        Ok(Expression::Operator(Operator {
+            kind,
+            lhs: Box::new(lhs),
+            rhs: Box::new(rhs),
+
+            matching: matching_clause,
+
+            span,
+        }))
+    }
+
+    fn expression_term(input: Node) -> Result<Expression> {
+        Ok(match_nodes!(input.into_children();
+          [signed_float(f)] => f,
+          [string(s)] => s,
+          [group(g)] => g,
+          [function(f)] => f,
+          [selector(s)] => s
+        ))
+    }
+
+    fn prometheus(input: Node) -> Result<Expression> {
+        Ok(match_nodes!(input.into_children();
+          [expression(e), EOI(_)] => e,
+        ))
+    }
 }
 
 /// Parses a Prometheus expression into a syntax tree.
 ///
-/// # Examples 
+/// # Examples
 ///
 /// ```
 /// use prometheus_parser::*;
 ///
 /// let ast = parse_expr("foo > bar").unwrap();
-/// 
+///
 /// assert_eq!(ast, Operator::new(
 ///   OperatorKind::GreaterThan,
 ///   Selector::new().metric("foo").span((0, 3)).wrap(),
@@ -449,10 +442,10 @@ impl PrometheusParser {
 /// ).span((3, 6)).wrap());
 /// ```
 pub fn parse_expr(expr: &str) -> Result<Expression> {
-  let inputs = PrometheusParser::parse(Rule::prometheus, expr)?;
-  let input = inputs.single()?;
+    let inputs = PrometheusParser::parse(Rule::prometheus, expr)?;
+    let input = inputs.single()?;
 
-  let expr = PrometheusParser::prometheus(input)?;
+    let expr = PrometheusParser::prometheus(input)?;
 
-  Ok(expr)
+    Ok(expr)
 }
diff --git a/src/types/expression.rs b/src/types/expression.rs
index c9ac9b2..9bd6193 100644
--- a/src/types/expression.rs
+++ b/src/types/expression.rs
@@ -13,116 +13,116 @@ use super::selector::Selector;
 /// These are all valid root expression types.
 #[derive(PartialEq, Clone)]
 pub enum Expression {
-  /// A single scalar float
-  Float(f64),
+    /// A single scalar float
+    Float(f64),
 
-  /// A single scalar string.
-  ///
-  /// Prometheus' docs claim strings aren't currently implemented, but they're
-  /// valid as function arguments.
-  String(String),
+    /// A single scalar string.
+    ///
+    /// Prometheus' docs claim strings aren't currently implemented, but they're
+    /// valid as function arguments.
+    String(String),
 
-  /// A metric selector
-  Selector(Selector),
+    /// A metric selector
+    Selector(Selector),
 
-  /// A grouped expression wrapped in parentheses
-  Group(Group),
+    /// A grouped expression wrapped in parentheses
+    Group(Group),
 
-  /// A function call
-  Function(Function),
+    /// A function call
+    Function(Function),
 
-  /// A binary operator expression
-  Operator(Operator)
+    /// A binary operator expression
+    Operator(Operator),
 }
 
 // For handling groups when testing
 impl Expression {
-  /// Wraps this Expression in a Group, consuming this Expression but returning
-  /// an owned Group.
-  pub fn group(self) -> Expression {
-    Group::new(self).wrap()
-  }
-
-  /// Determines a predicted `ReturnValue` for this Expression. A `ReturnValue`
-  /// includes a predicted data type and a set of label operations that may
-  /// affect which labels are returned.
-  pub fn return_value(&self) -> ReturnValue {
-    match self {
-      Expression::Float(_) => ReturnValue {
-        kind: ReturnKind::Scalar,
-        label_ops: vec![LabelSetOp::clear(self.clone(), None)]
-      },
-      Expression::String(_) => ReturnValue {
-        kind: ReturnKind::String,
-        label_ops: vec![LabelSetOp::clear(self.clone(), None)]
-      },
-      Expression::Selector(s) => s.return_value(),
-      Expression::Group(g) => g.return_value(),
-      Expression::Function(f) => f.return_value(),
-      Expression::Operator(o) => o.return_value()
+    /// Wraps this Expression in a Group, consuming this Expression but returning
+    /// an owned Group.
+    pub fn group(self) -> Expression {
+        Group::new(self).wrap()
     }
-  }
-
-  /// If this Expression is a Float, returns its value. Otherwise, returns None.
-  pub fn as_f64(&self) -> Option<f64> {
-    if let Expression::Float(f) = self {
-      Some(*f)
-    } else {
-      None
+
+    /// Determines a predicted `ReturnValue` for this Expression. A `ReturnValue`
+    /// includes a predicted data type and a set of label operations that may
+    /// affect which labels are returned.
+    pub fn return_value(&self) -> ReturnValue {
+        match self {
+            Expression::Float(_) => ReturnValue {
+                kind: ReturnKind::Scalar,
+                label_ops: vec![LabelSetOp::clear(self.clone(), None)],
+            },
+            Expression::String(_) => ReturnValue {
+                kind: ReturnKind::String,
+                label_ops: vec![LabelSetOp::clear(self.clone(), None)],
+            },
+            Expression::Selector(s) => s.return_value(),
+            Expression::Group(g) => g.return_value(),
+            Expression::Function(f) => f.return_value(),
+            Expression::Operator(o) => o.return_value(),
+        }
+    }
+
+    /// If this Expression is a Float, returns its value. Otherwise, returns None.
+    pub fn as_f64(&self) -> Option<f64> {
+        if let Expression::Float(f) = self {
+            Some(*f)
+        } else {
+            None
+        }
     }
-  }
-
-  /// If this Expression is a String, returns its value. Otherwise, returns
-  /// None.
-  pub fn as_str(&self) -> Option<&str> {
-    if let Expression::String(s) = self {
-      Some(s.as_str())
-    } else {
-      None
+
+    /// If this Expression is a String, returns its value. Otherwise, returns
+    /// None.
+    pub fn as_str(&self) -> Option<&str> {
+        if let Expression::String(s) = self {
+            Some(s.as_str())
+        } else {
+            None
+        }
     }
-  }
 }
 
 impl fmt::Debug for Expression {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    // don't bother formatting the Expression enum itself, this just creates
-    // tons of whitespace if we pretty-print
-    // this makes the output significantly more readable, if a bit misleading
-
-    // there's gotta be a better way to pass through flags...
-    if f.alternate() {
-      match self {
-        Expression::Float(val) => write!(f, "{:#?}", val),
-        Expression::String(val) => write!(f, "{:#?}", val),
-        Expression::Selector(val) => write!(f, "{:#?}", val),
-        Expression::Group(val) => write!(f, "{:#?}", val),
-        Expression::Function(val) => write!(f, "{:#?}", val),
-        Expression::Operator(val) => write!(f, "{:#?}", val),
-      }
-    } else {
-      match self {
-        Expression::Float(val) => write!(f, "{:?}", val),
-        Expression::String(val) => write!(f, "{:?}", val),
-        Expression::Selector(val) => write!(f, "{:?}", val),
-        Expression::Group(val) => write!(f, "{:?}", val),
-        Expression::Function(val) => write!(f, "{:?}", val),
-        Expression::Operator(val) => write!(f, "{:?}", val),
-      }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // don't bother formatting the Expression enum itself, this just creates
+        // tons of whitespace if we pretty-print
+        // this makes the output significantly more readable, if a bit misleading
+
+        // there's gotta be a better way to pass through flags...
+        if f.alternate() {
+            match self {
+                Expression::Float(val) => write!(f, "{:#?}", val),
+                Expression::String(val) => write!(f, "{:#?}", val),
+                Expression::Selector(val) => write!(f, "{:#?}", val),
+                Expression::Group(val) => write!(f, "{:#?}", val),
+                Expression::Function(val) => write!(f, "{:#?}", val),
+                Expression::Operator(val) => write!(f, "{:#?}", val),
+            }
+        } else {
+            match self {
+                Expression::Float(val) => write!(f, "{:?}", val),
+                Expression::String(val) => write!(f, "{:?}", val),
+                Expression::Selector(val) => write!(f, "{:?}", val),
+                Expression::Group(val) => write!(f, "{:?}", val),
+                Expression::Function(val) => write!(f, "{:?}", val),
+                Expression::Operator(val) => write!(f, "{:?}", val),
+            }
+        }
     }
-  }
 }
 
 impl fmt::Display for Expression {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    match self {
-      Expression::Float(val) => write!(f, "{}", val),
-      Expression::String(val) => write!(f, "{}", val),
-      Expression::Selector(val) => write!(f, "{}", val),
-      Expression::Group(val) => write!(f, "{}", val),
-      Expression::Function(val) => write!(f, "{}", val),
-      Expression::Operator(val) => write!(f, "{}", val),
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Expression::Float(val) => write!(f, "{}", val),
+            Expression::String(val) => write!(f, "{}", val),
+            Expression::Selector(val) => write!(f, "{}", val),
+            Expression::Group(val) => write!(f, "{}", val),
+            Expression::Function(val) => write!(f, "{}", val),
+            Expression::Operator(val) => write!(f, "{}", val),
+        }
     }
-  }
 }
 
 pub type BExpression = Box<Expression>;
diff --git a/src/types/function.rs b/src/types/function.rs
index d4c99af..06bcc70 100644
--- a/src/types/function.rs
+++ b/src/types/function.rs
@@ -4,24 +4,24 @@ use std::collections::HashSet;
 use std::fmt;
 use std::iter::FromIterator;
 
-use super::expression::{Expression, BExpression};
+use super::expression::{BExpression, Expression};
 use super::misc::{Span, Subquery};
-use super::return_value::{LabelSetOp, ReturnKind, ReturnValue, strs_to_set};
+use super::return_value::{strs_to_set, LabelSetOp, ReturnKind, ReturnValue};
 
 /// Aggregation operator types, namely "by" and "without"
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum AggregationOp {
-  By,
-  Without
+    By,
+    Without,
 }
 
 impl fmt::Display for AggregationOp {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    match self {
-      AggregationOp::By => write!(f, "by"),
-      AggregationOp::Without => write!(f, "without")
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AggregationOp::By => write!(f, "by"),
+            AggregationOp::Without => write!(f, "without"),
+        }
     }
-  }
 }
 
 /// A function aggregation clause.
@@ -30,77 +30,79 @@ impl fmt::Display for AggregationOp {
 /// attempt to validate this sort of usage.
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Aggregation {
-  pub op: AggregationOp,
-  pub labels: Vec<String>,
+    pub op: AggregationOp,
+    pub labels: Vec<String>,
 
-  pub span: Option<Span>
+    pub span: Option<Span>,
 }
 
 impl Aggregation {
-  pub fn new(op: AggregationOp) -> Self {
-    Aggregation {
-      op, labels: vec![], span: None
+    pub fn new(op: AggregationOp) -> Self {
+        Aggregation {
+            op,
+            labels: vec![],
+            span: None,
+        }
+    }
+
+    pub fn by() -> Self {
+        Aggregation::new(AggregationOp::By)
+    }
+
+    pub fn without() -> Self {
+        Aggregation::new(AggregationOp::Without)
+    }
+
+    /// Replaces this Aggregation's operator
+    pub fn op(mut self, op: AggregationOp) -> Self {
+        self.op = op;
+        self
+    }
+
+    /// Adds a label key to this Aggregation
+    pub fn label<S: Into<String>>(mut self, label: S) -> Self {
+        self.labels.push(label.into());
+        self
+    }
+
+    /// Replaces this Aggregation's labels with the given set
+    pub fn labels(mut self, labels: &[&str]) -> Self {
+        self.labels = labels.iter().map(|l| (*l).to_string()).collect();
+        self
+    }
+
+    /// Clear this Matching's set of labels
+    pub fn clear_labels(mut self) -> Self {
+        self.labels.clear();
+        self
+    }
+
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
     }
-  }
-
-  pub fn by() -> Self {
-    Aggregation::new(AggregationOp::By)
-  }
-
-  pub fn without() -> Self {
-    Aggregation::new(AggregationOp::Without)
-  }
-
-  /// Replaces this Aggregation's operator
-  pub fn op(mut self, op: AggregationOp) -> Self {
-    self.op = op;
-    self
-  }
-
-  /// Adds a label key to this Aggregation
-  pub fn label<S: Into<String>>(mut self, label: S) -> Self {
-    self.labels.push(label.into());
-    self
-  }
-
-  /// Replaces this Aggregation's labels with the given set
-  pub fn labels(mut self, labels: &[&str]) -> Self {
-    self.labels = labels.iter().map(|l| (*l).to_string()).collect();
-    self
-  }
-
-  /// Clear this Matching's set of labels
-  pub fn clear_labels(mut self) -> Self {
-    self.labels.clear();
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
 }
 
 impl fmt::Display for Aggregation {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{}", self.op)?;
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.op)?;
 
-    if !self.labels.is_empty() {
-      write!(f, " (")?;
+        if !self.labels.is_empty() {
+            write!(f, " (")?;
 
-      for (i, label) in self.labels.iter().enumerate() {
-        if i > 0 {
-          write!(f, ", ")?;
-        }
+            for (i, label) in self.labels.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
 
-        write!(f, "{}", label)?;
-      }
+                write!(f, "{}", label)?;
+            }
 
-      write!(f, ")")?;
-    }
+            write!(f, ")")?;
+        }
 
-    Ok(())
-  }
+        Ok(())
+    }
 }
 
 /// A function call.
@@ -109,28 +111,28 @@ impl fmt::Display for Aggregation {
 /// not validated.
 #[derive(Debug, PartialEq, Clone)]
 pub struct Function {
-  pub name: String,
-  pub args: Vec<BExpression>,
+    pub name: String,
+    pub args: Vec<BExpression>,
 
-  pub aggregation: Option<Aggregation>,
+    pub aggregation: Option<Aggregation>,
 
-  pub subquery: Option<Subquery>,
+    pub subquery: Option<Subquery>,
 
-  pub span: Option<Span>
+    pub span: Option<Span>,
 }
 
 /// Given a Prometheus function name, returns the argument index that determines
 /// the set of resulting labels
 fn arg_index_for_function(name: &str) -> Option<usize> {
-  Some(match name.to_lowercase().as_str() {
-    "time" => return None,
+    Some(match name.to_lowercase().as_str() {
+        "time" => return None,
 
-    "histogram_quantile" => 1,
-    "quantile_over_time" => 1,
+        "histogram_quantile" => 1,
+        "quantile_over_time" => 1,
 
-    // almost all functions use the first arg (often by only accepting 1 arg)
-    _ => 0
-  })
+        // almost all functions use the first arg (often by only accepting 1 arg)
+        _ => 0,
+    })
 }
 
 /// Determines if a given function converts a range vector to an instance vector
@@ -138,240 +140,252 @@ fn arg_index_for_function(name: &str) -> Option<usize> {
 /// Note that `_over_time` functions do not affect labels, unlike their regular
 /// counterparts
 fn is_aggregation_over_time(name: &str) -> bool {
-  match name.to_lowercase().as_str() {
-    // all the _over_time functions ...
-    "avg_over_time" | "min_over_time" | "max_over_time" => true,
-    "sum_over_time" | "count_over_time" | "quantile_over_time" => true,
-    "stddev_over_time" | "stdvar_over_time" => true,
-
-    // and also a few more
-    "delta" | "deriv" | "idelta" | "increase" | "predict_linear" => true,
-    "irate" | "rate" | "resets" => true,
-
-    _ => false
-  }
+    match name.to_lowercase().as_str() {
+        // all the _over_time functions ...
+        "avg_over_time" | "min_over_time" | "max_over_time" => true,
+        "sum_over_time" | "count_over_time" | "quantile_over_time" => true,
+        "stddev_over_time" | "stdvar_over_time" => true,
+
+        // and also a few more
+        "delta" | "deriv" | "idelta" | "increase" | "predict_linear" => true,
+        "irate" | "rate" | "resets" => true,
+
+        _ => false,
+    }
 }
 
 /// Determines if a given function is an aggregation function
 fn is_aggregation(name: &str) -> bool {
-  match name.to_lowercase().as_str() {
-    "sum" | "min" | "max" | "avg" | "stddev" | "stdvar" | "count" => true,
-    "count_values" | "bottomk" | "topk" | "quantile" => true,
-    _ => false
-  }
+    match name.to_lowercase().as_str() {
+        "sum" | "min" | "max" | "avg" | "stddev" | "stdvar" | "count" => true,
+        "count_values" | "bottomk" | "topk" | "quantile" => true,
+        _ => false,
+    }
 }
 
 impl Function {
-  pub fn new<S: Into<String>>(name: S) -> Function {
-    Function {
-      name: name.into(),
-      args: vec![],
-      aggregation: None,
-      subquery: None,
-      span: None
+    pub fn new<S: Into<String>>(name: S) -> Function {
+        Function {
+            name: name.into(),
+            args: vec![],
+            aggregation: None,
+            subquery: None,
+            span: None,
+        }
+    }
+
+    /// Replaces this Function's name with the given string
+    ///
+    /// Note that the new name is not validated.
+    pub fn name<S: Into<String>>(mut self, name: S) -> Self {
+        self.name = name.into();
+        self
     }
-  }
-
-  /// Replaces this Function's name with the given string
-  ///
-  /// Note that the new name is not validated.
-  pub fn name<S: Into<String>>(mut self, name: S) -> Self {
-    self.name = name.into();
-    self
-  }
-
-  /// Adds the given expression as new argument to this function 
-  pub fn arg(mut self, arg: Expression) -> Self {
-    self.args.push(Box::new(arg));
-    self
-  }
-
-  /// Sets this Function's aggregation clause
-  pub fn aggregation(mut self, aggregation: Aggregation) -> Self {
-    self.aggregation = Some(aggregation);
-    self
-  }
-
-  /// Clears this Function's aggregation clause, if any 
-  pub fn clear_aggregation(mut self) -> Self {
-    self.aggregation = None;
-    self
-  }
-
-  pub fn subquery(mut self, subquery: Subquery) -> Self {
-    self.subquery = Some(subquery);
-    self
-  }
-
-  pub fn clear_subquery(mut self) -> Self {
-    self.subquery = None;
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
-
-  /// Wraps this function in an Expression
-  pub fn wrap(self) -> Expression {
-    Expression::Function(self)
-  }
-
-  pub fn return_value(&self) -> ReturnValue {
-    // functions generally pass through labels of one of their arguments, with
-    // some exceptions
-
-    // determine the arg to pass through
-    let labels_arg_index = match arg_index_for_function(&self.name) {
-      Some(index) => index,
-
-      // only `time(...)` accepts no arguments and always returns a scalar
-      None => return ReturnValue {
-        kind: ReturnKind::Scalar,
-        label_ops: vec![LabelSetOp::clear(self.clone().wrap(), self.span)]
-      }
-    };
-
-    // if the function call is invalid, bail with unknowns
-    let labels_arg = match self.args.get(labels_arg_index) {
-      Some(arg) => arg,
-      None => return ReturnValue {
-        kind: ReturnKind::unknown(
-          format!(
-            "function call {}(...) is missing a required argument at index {}",
-            self.name, labels_arg_index
-          ),
-          self.clone().wrap()
-        ),
-
-        // we can't predict what will happen with labels, but we can at least
-        // try to output _something_
-        label_ops: vec![]
-      }
-    };
-
-    let arg_return = labels_arg.return_value();
-    
-    let mut kind = arg_return.kind;
-    let mut label_ops = arg_return.label_ops;
-
-    if is_aggregation_over_time(&self.name) {
-      if let ReturnKind::RangeVector = kind {
-        kind = ReturnKind::InstantVector;
-      } else {
-        // invalid arg
-        kind = ReturnKind::unknown(
-          format!("aggregation over time is not valid with expression returning {:?}", kind),
-
-          // show the label arg as the cause
-          // doesn't follow the usual pattern of showing the parent, but would
-          // otherwise be ambiguous with multiple args
-          *labels_arg.clone()
-        );
-      }
+
+    /// Adds the given expression as new argument to this function
+    pub fn arg(mut self, arg: Expression) -> Self {
+        self.args.push(Box::new(arg));
+        self
     }
 
-    // aggregation functions reset labels unless they have an aggregation clause
-    // (handled below)
-    let is_agg = is_aggregation(&self.name);
-
-    // aggregations turn range vectors into instant vectors
-    if let Some(agg) = &self.aggregation {
-      match agg.op {
-        AggregationOp::By => {
-          // by (...) resets labels to only those in the by clause
-          label_ops.push(LabelSetOp::clear(self.clone().wrap(), agg.span));
-          label_ops.push(LabelSetOp::append(
-            self.clone().wrap(),
-            agg.span,
-            HashSet::from_iter(agg.labels.iter().cloned())
-          ));
-        },
-        AggregationOp::Without => label_ops.push(LabelSetOp::remove(
-          self.clone().wrap(),
-          agg.span,
-          HashSet::from_iter(agg.labels.iter().cloned()),
-        ))
-      }
-    } else if is_agg {
-      // an aggregation function with no aggregation clause clears all labels
-      label_ops.push(LabelSetOp::clear(self.clone().wrap(), self.span));
+    /// Sets this Function's aggregation clause
+    pub fn aggregation(mut self, aggregation: Aggregation) -> Self {
+        self.aggregation = Some(aggregation);
+        self
     }
-    
-    // handle special cases with functions that mutate labels
-    match self.name.to_lowercase().as_str() {
-      // creats a new label with contents of others, leaves them intact
-      "label_join" => if let Some(expr) = self.args.get(1) {
-        if let Some(s) = expr.as_str() {
-          label_ops.push(LabelSetOp::append(
-            self.clone().wrap(),
-            self.span,
-            strs_to_set(&[s])
-          ));
-        }
-      },
-
-      // note: does not remove src_label
-      "label_replace" => if let Some(expr) = self.args.get(1) {
-        if let Some(s) = expr.as_str() {
-          label_ops.push(LabelSetOp::append(
-            self.clone().wrap(),
-            self.span,
-            strs_to_set(&[s])
-          ));
-        }
-      },
 
-      // per docs, input vector must have an `le` label
-      "histogram_quantile" => label_ops.push(LabelSetOp::append(
-        self.clone().wrap(),
-        self.span,
-        strs_to_set(&["le"])
-      )),
+    /// Clears this Function's aggregation clause, if any
+    pub fn clear_aggregation(mut self) -> Self {
+        self.aggregation = None;
+        self
+    }
 
-      // "vector" => // no-op, its input expr is a scalar anyway
+    pub fn subquery(mut self, subquery: Subquery) -> Self {
+        self.subquery = Some(subquery);
+        self
+    }
 
-      _ => ()
+    pub fn clear_subquery(mut self) -> Self {
+        self.subquery = None;
+        self
     }
 
-    // subqueries turn instant vectors into ranges
-    if self.subquery.is_some() {
-      kind = match kind {
-        ReturnKind::InstantVector => ReturnKind::RangeVector,
-        _ => ReturnKind::unknown(
-          format!("subquery on inner expression returning {:?} is invalid", kind),
-          self.clone().wrap()
-        )
-      };
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
     }
 
-    ReturnValue { kind, label_ops }
-  }
+    /// Wraps this function in an Expression
+    pub fn wrap(self) -> Expression {
+        Expression::Function(self)
+    }
+
+    pub fn return_value(&self) -> ReturnValue {
+        // functions generally pass through labels of one of their arguments, with
+        // some exceptions
+
+        // determine the arg to pass through
+        let labels_arg_index = match arg_index_for_function(&self.name) {
+            Some(index) => index,
+
+            // only `time(...)` accepts no arguments and always returns a scalar
+            None => {
+                return ReturnValue {
+                    kind: ReturnKind::Scalar,
+                    label_ops: vec![LabelSetOp::clear(self.clone().wrap(), self.span)],
+                }
+            }
+        };
+
+        // if the function call is invalid, bail with unknowns
+        let labels_arg = match self.args.get(labels_arg_index) {
+            Some(arg) => arg,
+            None => {
+                return ReturnValue {
+                    kind: ReturnKind::unknown(
+                        format!(
+                            "function call {}(...) is missing a required argument at index {}",
+                            self.name, labels_arg_index
+                        ),
+                        self.clone().wrap(),
+                    ),
+
+                    // we can't predict what will happen with labels, but we can at least
+                    // try to output _something_
+                    label_ops: vec![],
+                };
+            }
+        };
+
+        let arg_return = labels_arg.return_value();
+
+        let mut kind = arg_return.kind;
+        let mut label_ops = arg_return.label_ops;
+
+        if is_aggregation_over_time(&self.name) {
+            if let ReturnKind::RangeVector = kind {
+                kind = ReturnKind::InstantVector;
+            } else {
+                // invalid arg
+                kind = ReturnKind::unknown(
+                    format!(
+                        "aggregation over time is not valid with expression returning {:?}",
+                        kind
+                    ),
+                    // show the label arg as the cause
+                    // doesn't follow the usual pattern of showing the parent, but would
+                    // otherwise be ambiguous with multiple args
+                    *labels_arg.clone(),
+                );
+            }
+        }
+
+        // aggregation functions reset labels unless they have an aggregation clause
+        // (handled below)
+        let is_agg = is_aggregation(&self.name);
+
+        // aggregations turn range vectors into instant vectors
+        if let Some(agg) = &self.aggregation {
+            match agg.op {
+                AggregationOp::By => {
+                    // by (...) resets labels to only those in the by clause
+                    label_ops.push(LabelSetOp::clear(self.clone().wrap(), agg.span));
+                    label_ops.push(LabelSetOp::append(
+                        self.clone().wrap(),
+                        agg.span,
+                        HashSet::from_iter(agg.labels.iter().cloned()),
+                    ));
+                }
+                AggregationOp::Without => label_ops.push(LabelSetOp::remove(
+                    self.clone().wrap(),
+                    agg.span,
+                    HashSet::from_iter(agg.labels.iter().cloned()),
+                )),
+            }
+        } else if is_agg {
+            // an aggregation function with no aggregation clause clears all labels
+            label_ops.push(LabelSetOp::clear(self.clone().wrap(), self.span));
+        }
+
+        // handle special cases with functions that mutate labels
+        match self.name.to_lowercase().as_str() {
+            // creats a new label with contents of others, leaves them intact
+            "label_join" => {
+                if let Some(expr) = self.args.get(1) {
+                    if let Some(s) = expr.as_str() {
+                        label_ops.push(LabelSetOp::append(
+                            self.clone().wrap(),
+                            self.span,
+                            strs_to_set(&[s]),
+                        ));
+                    }
+                }
+            }
+
+            // note: does not remove src_label
+            "label_replace" => {
+                if let Some(expr) = self.args.get(1) {
+                    if let Some(s) = expr.as_str() {
+                        label_ops.push(LabelSetOp::append(
+                            self.clone().wrap(),
+                            self.span,
+                            strs_to_set(&[s]),
+                        ));
+                    }
+                }
+            }
+
+            // per docs, input vector must have an `le` label
+            "histogram_quantile" => label_ops.push(LabelSetOp::append(
+                self.clone().wrap(),
+                self.span,
+                strs_to_set(&["le"]),
+            )),
+
+            // "vector" => // no-op, its input expr is a scalar anyway
+            _ => (),
+        }
+
+        // subqueries turn instant vectors into ranges
+        if self.subquery.is_some() {
+            kind = match kind {
+                ReturnKind::InstantVector => ReturnKind::RangeVector,
+                _ => ReturnKind::unknown(
+                    format!(
+                        "subquery on inner expression returning {:?} is invalid",
+                        kind
+                    ),
+                    self.clone().wrap(),
+                ),
+            };
+        }
+
+        ReturnValue { kind, label_ops }
+    }
 }
 
 impl fmt::Display for Function {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{}(", self.name)?;
-    
-    for (i, arg) in self.args.iter().enumerate() {
-      if i > 0 {
-        write!(f, ", ")?;
-      }
-
-      write!(f, "{}", arg)?;
-    }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}(", self.name)?;
 
-    write!(f, ")")?;
+        for (i, arg) in self.args.iter().enumerate() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
 
-    if let Some(agg) = &self.aggregation {
-      write!(f, " {}", agg)?;
-    }
+            write!(f, "{}", arg)?;
+        }
 
-    if let Some(subquery) = &self.subquery {
-      write!(f, "{}", subquery)?;
-    }
+        write!(f, ")")?;
+
+        if let Some(agg) = &self.aggregation {
+            write!(f, " {}", agg)?;
+        }
 
-    Ok(())
-  }
+        if let Some(subquery) = &self.subquery {
+            write!(f, "{}", subquery)?;
+        }
+
+        Ok(())
+    }
 }
diff --git a/src/types/group.rs b/src/types/group.rs
index 22d2bc2..6e5db60 100644
--- a/src/types/group.rs
+++ b/src/types/group.rs
@@ -3,71 +3,74 @@
 use std::fmt;
 
 use super::expression::{BExpression, Expression};
-use super::return_value::{ReturnKind, ReturnValue};
 use super::misc::{Span, Subquery};
+use super::return_value::{ReturnKind, ReturnValue};
 
 /// An expression explicitly grouped in parens
 #[derive(Debug, PartialEq, Clone)]
 pub struct Group {
-  pub expression: BExpression,
-  pub subquery: Option<Subquery>,
-  pub span: Option<Span>
+    pub expression: BExpression,
+    pub subquery: Option<Subquery>,
+    pub span: Option<Span>,
 }
 
 impl Group {
-  pub fn new(expression: Expression) -> Self {
-    Group {
-      expression: Box::new(expression),
-      subquery: None,
-      span: None
+    pub fn new(expression: Expression) -> Self {
+        Group {
+            expression: Box::new(expression),
+            subquery: None,
+            span: None,
+        }
     }
-  }
 
-  pub fn subquery(mut self, subquery: Subquery) -> Self {
-    self.subquery = Some(subquery);
-    self
-  }
+    pub fn subquery(mut self, subquery: Subquery) -> Self {
+        self.subquery = Some(subquery);
+        self
+    }
+
+    pub fn clear_subquery(mut self) -> Self {
+        self.subquery = None;
+        self
+    }
 
-  pub fn clear_subquery(mut self) -> Self {
-    self.subquery = None;
-    self
-  }
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
+    }
 
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
+    /// Wraps this function in an Expression
+    pub fn wrap(self) -> Expression {
+        Expression::Group(self)
+    }
 
-  /// Wraps this function in an Expression
-  pub fn wrap(self) -> Expression {
-    Expression::Group(self)
-  }
+    pub fn return_value(&self) -> ReturnValue {
+        let mut ret = self.expression.return_value();
 
-  pub fn return_value(&self) -> ReturnValue {
-    let mut ret = self.expression.return_value();
+        if self.subquery.is_some() {
+            ret.kind = match ret.kind {
+                ReturnKind::InstantVector => ReturnKind::RangeVector,
+                _ => ReturnKind::unknown(
+                    format!(
+                        "subquery on inner expression returning {:?} is invalid",
+                        ret.kind
+                    ),
+                    self.clone().wrap(),
+                ),
+            };
+        }
 
-    if self.subquery.is_some() {
-      ret.kind = match ret.kind {
-        ReturnKind::InstantVector => ReturnKind::RangeVector,
-        _ => ReturnKind::unknown(
-          format!("subquery on inner expression returning {:?} is invalid", ret.kind),
-          self.clone().wrap()
-        )
-      };
+        ret
     }
-
-    ret
-  }
 }
 
 impl fmt::Display for Group {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "({})", self.expression)?;
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "({})", self.expression)?;
 
-    if let Some(subquery) = &self.subquery {
-      write!(f, "{}", subquery)?;
-    }
+        if let Some(subquery) = &self.subquery {
+            write!(f, "{}", subquery)?;
+        }
 
-    Ok(())
-  }
+        Ok(())
+    }
 }
diff --git a/src/types/misc.rs b/src/types/misc.rs
index 6b796a1..3e28799 100644
--- a/src/types/misc.rs
+++ b/src/types/misc.rs
@@ -8,133 +8,133 @@ use std::fmt;
 /// parser rather than the output of an expression's `Display` impl.
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct Span {
-  pub start: usize,
-  pub end: usize
+    pub start: usize,
+    pub end: usize,
 }
 
 impl From<(usize, usize)> for Span {
-  fn from(tup: (usize, usize)) -> Span {
-    Span::new(tup.0, tup.1)
-  }
+    fn from(tup: (usize, usize)) -> Span {
+        Span::new(tup.0, tup.1)
+    }
 }
 
 impl Span {
-  pub fn new(start: usize, end: usize) -> Self {
-    Span { start, end }
-  }
-
-  pub(crate) fn from_node(node: &crate::parser::Node) -> Self {
-    let span = node.as_span();
-    Span {
-      start: span.start(),
-      end: span.end()
+    pub fn new(start: usize, end: usize) -> Self {
+        Span { start, end }
+    }
+
+    pub(crate) fn from_node(node: &crate::parser::Node) -> Self {
+        let span = node.as_span();
+        Span {
+            start: span.start(),
+            end: span.end(),
+        }
     }
-  }
 }
 
 impl fmt::Display for Span {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "({}, {})", self.start, self.end)
-  }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "({}, {})", self.start, self.end)
+    }
 }
 
 /// A Prometheus duration
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum PromDuration {
-  Seconds(u64),
-  Minutes(u64),
-  Hours(u64),
-  Days(u64),
-  Weeks(u64),
-  Years(u64)
+    Seconds(u64),
+    Minutes(u64),
+    Hours(u64),
+    Days(u64),
+    Weeks(u64),
+    Years(u64),
 }
 
 type StringResult<T> = std::result::Result<T, String>;
 
 impl PromDuration {
-  pub fn from_pair(unit: &str, value: u64) -> StringResult<PromDuration> {
-    Ok(match unit {
-      "s" => PromDuration::Seconds(value),
-      "m" => PromDuration::Minutes(value),
-      "h" => PromDuration::Hours(value),
-      "d" => PromDuration::Days(value),
-      "w" => PromDuration::Weeks(value),
-      "y" => PromDuration::Years(value),
-      u => return Err(format!("invalid duration unit: {:?}", u))
-    })
-  }
-
-  pub fn as_char(self) -> char {
-    match self {
-      PromDuration::Seconds(_) => 's',
-      PromDuration::Minutes(_) => 'm',
-      PromDuration::Hours(_) => 'h',
-      PromDuration::Days(_) => 'd',
-      PromDuration::Weeks(_) => 'w',
-      PromDuration::Years(_) => 'y'
+    pub fn from_pair(unit: &str, value: u64) -> StringResult<PromDuration> {
+        Ok(match unit {
+            "s" => PromDuration::Seconds(value),
+            "m" => PromDuration::Minutes(value),
+            "h" => PromDuration::Hours(value),
+            "d" => PromDuration::Days(value),
+            "w" => PromDuration::Weeks(value),
+            "y" => PromDuration::Years(value),
+            u => return Err(format!("invalid duration unit: {:?}", u)),
+        })
+    }
+
+    pub fn as_char(self) -> char {
+        match self {
+            PromDuration::Seconds(_) => 's',
+            PromDuration::Minutes(_) => 'm',
+            PromDuration::Hours(_) => 'h',
+            PromDuration::Days(_) => 'd',
+            PromDuration::Weeks(_) => 'w',
+            PromDuration::Years(_) => 'y',
+        }
     }
-  }
 }
 
 impl fmt::Display for PromDuration {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    let v = match self {
-      PromDuration::Seconds(v) => v,
-      PromDuration::Minutes(v) => v,
-      PromDuration::Hours(v) => v,
-      PromDuration::Days(v) => v,
-      PromDuration::Weeks(v) => v,
-      PromDuration::Years(v) => v
-    };
-
-    write!(f, "{}{}", v, self.as_char())
-  }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let v = match self {
+            PromDuration::Seconds(v) => v,
+            PromDuration::Minutes(v) => v,
+            PromDuration::Hours(v) => v,
+            PromDuration::Days(v) => v,
+            PromDuration::Weeks(v) => v,
+            PromDuration::Years(v) => v,
+        };
+
+        write!(f, "{}{}", v, self.as_char())
+    }
 }
 
 /// A Subquery which converts an instant vector to a range vector by repeatedly
 /// evaluating it at set intervals into the relative past
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Subquery {
-  /// Duration back in time to begin the subquery
-  pub range: PromDuration,
+    /// Duration back in time to begin the subquery
+    pub range: PromDuration,
 
-  /// Optional step size. If unset, uses the global/query default at runtime.
-  pub resolution: Option<PromDuration>,
+    /// Optional step size. If unset, uses the global/query default at runtime.
+    pub resolution: Option<PromDuration>,
 
-  pub span: Option<Span>
+    pub span: Option<Span>,
 }
 
 impl Subquery {
-  pub fn new(range: PromDuration) -> Self {
-    Subquery {
-      range,
-      resolution: None,
-      span: None
+    pub fn new(range: PromDuration) -> Self {
+        Subquery {
+            range,
+            resolution: None,
+            span: None,
+        }
+    }
+
+    pub fn resolution(mut self, res: PromDuration) -> Self {
+        self.resolution = Some(res);
+        self
+    }
+
+    pub fn clear_resolution(mut self) -> Self {
+        self.resolution = None;
+        self
+    }
+
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
     }
-  }
-
-  pub fn resolution(mut self, res: PromDuration) -> Self {
-    self.resolution = Some(res);
-    self
-  }
-
-  pub fn clear_resolution(mut self) -> Self {
-    self.resolution = None;
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
 }
 
 impl fmt::Display for Subquery {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    if let Some(res) = self.resolution {
-      write!(f, "[{}:{}]", self.range, res)
-    } else {
-      write!(f, "[{}:]", self.range)
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(res) = self.resolution {
+            write!(f, "[{}:{}]", self.range, res)
+        } else {
+            write!(f, "[{}:]", self.range)
+        }
     }
-  }
 }
diff --git a/src/types/operator.rs b/src/types/operator.rs
index ad4072f..1956b86 100644
--- a/src/types/operator.rs
+++ b/src/types/operator.rs
@@ -3,262 +3,270 @@
 use std::fmt;
 
 use super::expression::{BExpression, Expression};
-use super::return_value::{LabelSetOp, ReturnKind, ReturnValue};
 use super::misc::Span;
+use super::return_value::{LabelSetOp, ReturnKind, ReturnValue};
 
 /// All legal binary operator types
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum OperatorKind {
-  Power,
-  Multiply, Divide, Modulo,
-  Add, Subtract,
-  Equal, NotEqual,
-  LessThan, LessThanEqual,
-  GreaterThan, GreaterThanEqual,
-  And, Unless, Or
+    Power,
+    Multiply,
+    Divide,
+    Modulo,
+    Add,
+    Subtract,
+    Equal,
+    NotEqual,
+    LessThan,
+    LessThanEqual,
+    GreaterThan,
+    GreaterThanEqual,
+    And,
+    Unless,
+    Or,
 }
 
 impl OperatorKind {
-  pub fn as_str(self) -> &'static str {
-    use OperatorKind::*;
-    match self {
-      Power => "^",
-      Multiply => "*",
-      Divide => "/",
-      Modulo => "%",
-      Add => "+",
-      Subtract => "-",
-      Equal => "==",
-      NotEqual => "!=",
-      LessThan => "<",
-      LessThanEqual => "<=",
-      GreaterThan => ">",
-      GreaterThanEqual => ">=",
-      And => "and",
-      Unless => "unless",
-      Or => "or"
+    pub fn as_str(self) -> &'static str {
+        use OperatorKind::*;
+        match self {
+            Power => "^",
+            Multiply => "*",
+            Divide => "/",
+            Modulo => "%",
+            Add => "+",
+            Subtract => "-",
+            Equal => "==",
+            NotEqual => "!=",
+            LessThan => "<",
+            LessThanEqual => "<=",
+            GreaterThan => ">",
+            GreaterThanEqual => ">=",
+            And => "and",
+            Unless => "unless",
+            Or => "or",
+        }
     }
-  }
 }
 
 impl fmt::Display for OperatorKind {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{}", self.as_str())
-  }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
 }
 
 /// Matching group clause types (`group_left`, `group_right`)
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum MatchingGroupOp {
-  Left,
-  Right
+    Left,
+    Right,
 }
 
 impl fmt::Display for MatchingGroupOp {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    match self {
-      MatchingGroupOp::Left => write!(f, "group_left"),
-      MatchingGroupOp::Right => write!(f, "group_right")
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            MatchingGroupOp::Left => write!(f, "group_left"),
+            MatchingGroupOp::Right => write!(f, "group_right"),
+        }
     }
-  }
 }
 
 /// A matching clause's nested grouping clause
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct MatchingGroup {
-  /// The matching group's operator type (left or right)
-  pub op: MatchingGroupOp,
+    /// The matching group's operator type (left or right)
+    pub op: MatchingGroupOp,
 
-  /// A list of labels to copy to the opposite side of the group operator, i.e.
-  /// group_left(foo) copies the label `foo` from the right hand side
-  pub labels: Vec<String>,
+    /// A list of labels to copy to the opposite side of the group operator, i.e.
+    /// group_left(foo) copies the label `foo` from the right hand side
+    pub labels: Vec<String>,
 
-  pub span: Option<Span>
+    pub span: Option<Span>,
 }
 
 impl MatchingGroup {
-  pub fn new(op: MatchingGroupOp) -> Self {
-    MatchingGroup {
-      op,
-      labels: vec![],
-      span: None
+    pub fn new(op: MatchingGroupOp) -> Self {
+        MatchingGroup {
+            op,
+            labels: vec![],
+            span: None,
+        }
+    }
+
+    /// Creates a new MatchingGroup with the Left op
+    pub fn left() -> Self {
+        MatchingGroup::new(MatchingGroupOp::Left)
+    }
+
+    /// Creates a new MatchingGroup with the Right op
+    pub fn right() -> Self {
+        MatchingGroup::new(MatchingGroupOp::Right)
+    }
+
+    /// Replaces this Matching's operator
+    pub fn op(mut self, op: MatchingGroupOp) -> Self {
+        self.op = op;
+        self
+    }
+
+    /// Adds a label key to this MatchingGroup
+    pub fn label<S: Into<String>>(mut self, label: S) -> Self {
+        self.labels.push(label.into());
+        self
+    }
+
+    /// Replaces this MatchingGroup's labels with the given set
+    pub fn labels(mut self, labels: &[&str]) -> Self {
+        self.labels = labels.iter().map(|l| (*l).to_string()).collect();
+        self
+    }
+
+    /// Clears this MatchingGroup's set of labels
+    pub fn clear_labels(mut self) -> Self {
+        self.labels.clear();
+        self
+    }
+
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
     }
-  }
-
-  /// Creates a new MatchingGroup with the Left op
-  pub fn left() -> Self {
-    MatchingGroup::new(MatchingGroupOp::Left)
-  }
-
-  /// Creates a new MatchingGroup with the Right op
-  pub fn right() -> Self {
-    MatchingGroup::new(MatchingGroupOp::Right)
-  }
-
-  /// Replaces this Matching's operator
-  pub fn op(mut self, op: MatchingGroupOp) -> Self {
-    self.op = op;
-    self
-  }
-
-  /// Adds a label key to this MatchingGroup
-  pub fn label<S: Into<String>>(mut self, label: S) -> Self {
-    self.labels.push(label.into());
-    self
-  }
-
-  /// Replaces this MatchingGroup's labels with the given set
-  pub fn labels(mut self, labels: &[&str]) -> Self {
-    self.labels = labels.iter().map(|l| (*l).to_string()).collect();
-    self
-  }
-
-  /// Clears this MatchingGroup's set of labels
-  pub fn clear_labels(mut self) -> Self {
-    self.labels.clear();
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
 }
 
 impl fmt::Display for MatchingGroup {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{}", self.op)?;
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.op)?;
 
-    if !self.labels.is_empty() {
-      write!(f, "(")?;
+        if !self.labels.is_empty() {
+            write!(f, "(")?;
 
-      for (i, label) in self.labels.iter().enumerate() {
-        if i > 0 {
-          write!(f, ", ")?;
-        }
+            for (i, label) in self.labels.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
 
-        write!(f, "{}", label)?;
-      }
+                write!(f, "{}", label)?;
+            }
 
-      write!(f, ")")?;
-    }
+            write!(f, ")")?;
+        }
 
-    Ok(())
-  }
+        Ok(())
+    }
 }
 
 /// A matching clause type
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum MatchingOp {
-  On,
-  Ignoring
+    On,
+    Ignoring,
 }
 
 impl fmt::Display for MatchingOp {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    match self {
-      MatchingOp::On => write!(f, "on"),
-      MatchingOp::Ignoring => write!(f, "ignoring")
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            MatchingOp::On => write!(f, "on"),
+            MatchingOp::Ignoring => write!(f, "ignoring"),
+        }
     }
-  }
 }
 
 /// An operator matching clause
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Matching {
-  pub op: MatchingOp,
+    pub op: MatchingOp,
 
-  /// A list of labels to which the operator is applied
-  pub labels: Vec<String>,
+    /// A list of labels to which the operator is applied
+    pub labels: Vec<String>,
 
-  /// An optional grouping clause for many-to-one and one-to-many vector matches
-  pub group: Option<MatchingGroup>,
+    /// An optional grouping clause for many-to-one and one-to-many vector matches
+    pub group: Option<MatchingGroup>,
 
-  pub span: Option<Span>
+    pub span: Option<Span>,
 }
 
 impl Matching {
-  pub fn new(op: MatchingOp) -> Self {
-    Matching {
-      op,
-      labels: vec![],
-      group: None,
-      span: None
+    pub fn new(op: MatchingOp) -> Self {
+        Matching {
+            op,
+            labels: vec![],
+            group: None,
+            span: None,
+        }
     }
-  }
-
-  /// Creates a Matching cause with the On operator
-  pub fn on() -> Self {
-    Matching::new(MatchingOp::On)
-  }
-
-  /// Creates a Matching clause using the Ignoring operator
-  pub fn ignoring() -> Self {
-    Matching::new(MatchingOp::Ignoring)
-  }
-
-  /// Replaces this Matching's operator
-  pub fn op(mut self, op: MatchingOp) -> Self {
-    self.op = op;
-    self
-  }
-
-  /// Adds a label key to this Matching
-  pub fn label<S: Into<String>>(mut self, label: S) -> Self {
-    self.labels.push(label.into());
-    self
-  }
-
-  /// Replaces this Matching's labels with the given set
-  pub fn labels(mut self, labels: &[&str]) -> Self {
-    self.labels = labels.iter().map(|l| (*l).to_string()).collect();
-    self
-  }
-
-  /// Clears this Matching's set of labels
-  pub fn clear_labels(mut self) -> Self {
-    self.labels.clear();
-    self
-  }
-
-  /// Sets or replaces this Matching's group clause
-  pub fn group(mut self, group: MatchingGroup) -> Self {
-    self.group = Some(group);
-    self
-  }
-
-  /// Clears this Matching's group clause
-  pub fn clear_group(mut self) -> Self {
-    self.group = None;
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
-}
 
-impl fmt::Display for Matching {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{}(", self.op)?;
+    /// Creates a Matching cause with the On operator
+    pub fn on() -> Self {
+        Matching::new(MatchingOp::On)
+    }
 
-    for (i, label) in self.labels.iter().enumerate() {
-      if i > 0 {
-        write!(f, ", ")?;
-      }
+    /// Creates a Matching clause using the Ignoring operator
+    pub fn ignoring() -> Self {
+        Matching::new(MatchingOp::Ignoring)
+    }
 
-      write!(f, "{}", label)?;
+    /// Replaces this Matching's operator
+    pub fn op(mut self, op: MatchingOp) -> Self {
+        self.op = op;
+        self
     }
 
-    write!(f, ")")?;
+    /// Adds a label key to this Matching
+    pub fn label<S: Into<String>>(mut self, label: S) -> Self {
+        self.labels.push(label.into());
+        self
+    }
 
-    if let Some(group) = &self.group {
-      write!(f, " {}", group)?;
+    /// Replaces this Matching's labels with the given set
+    pub fn labels(mut self, labels: &[&str]) -> Self {
+        self.labels = labels.iter().map(|l| (*l).to_string()).collect();
+        self
     }
 
-    Ok(())
-  }
+    /// Clears this Matching's set of labels
+    pub fn clear_labels(mut self) -> Self {
+        self.labels.clear();
+        self
+    }
+
+    /// Sets or replaces this Matching's group clause
+    pub fn group(mut self, group: MatchingGroup) -> Self {
+        self.group = Some(group);
+        self
+    }
+
+    /// Clears this Matching's group clause
+    pub fn clear_group(mut self) -> Self {
+        self.group = None;
+        self
+    }
+
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
+    }
+}
+
+impl fmt::Display for Matching {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}(", self.op)?;
+
+        for (i, label) in self.labels.iter().enumerate() {
+            if i > 0 {
+                write!(f, ", ")?;
+            }
+
+            write!(f, "{}", label)?;
+        }
+
+        write!(f, ")")?;
+
+        if let Some(group) = &self.group {
+            write!(f, " {}", group)?;
+        }
+
+        Ok(())
+    }
 }
 
 /// A binary operator expression with left- and right-hand sides.
@@ -271,138 +279,144 @@ impl fmt::Display for Matching {
 /// un-grouped expressions at the same syntax level.
 #[derive(Debug, PartialEq, Clone)]
 pub struct Operator {
-  /// This Operator's function (multiply, divide, power, equals, etc)
-  pub kind: OperatorKind,
+    /// This Operator's function (multiply, divide, power, equals, etc)
+    pub kind: OperatorKind,
 
-  /// The left-hand-side expression
-  pub lhs: BExpression,
+    /// The left-hand-side expression
+    pub lhs: BExpression,
 
-  /// The right-hand-side expression
-  pub rhs: BExpression,
+    /// The right-hand-side expression
+    pub rhs: BExpression,
 
-  /// An optional matching clause for this operator (`on(...)`, `ignoring(...)`)
-  pub matching: Option<Matching>,
+    /// An optional matching clause for this operator (`on(...)`, `ignoring(...)`)
+    pub matching: Option<Matching>,
 
-  pub span: Option<Span>
+    pub span: Option<Span>,
 }
 
 impl Operator {
-  pub fn new(kind: OperatorKind, lhs: Expression, rhs: Expression) -> Self {
-    Operator {
-      kind,
-      lhs: Box::new(lhs),
-      rhs: Box::new(rhs),
-      matching: None,
-      span: None
+    pub fn new(kind: OperatorKind, lhs: Expression, rhs: Expression) -> Self {
+        Operator {
+            kind,
+            lhs: Box::new(lhs),
+            rhs: Box::new(rhs),
+            matching: None,
+            span: None,
+        }
     }
-  }
-
-  /// Sets or replaces this Operator's Matching clause
-  pub fn matching(mut self, matching: Matching) -> Self {
-    self.matching = Some(matching);
-    self
-  }
-
-  /// Clears this Operator's Matching clause, if any
-  pub fn clear_matching(mut self) -> Self {
-    self.matching = None;
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
-
-  /// Wraps this Operator in an Expression
-  pub fn wrap(self) -> Expression {
-    Expression::Operator(self)
-  }
-
-  pub fn return_value(&self) -> ReturnValue {
-    // note: largely based on the description from:
-    // https://www.robustperception.io/using-group_left-to-calculate-label-proportions
-
-    // binary operator exprs can only contain (and return) instant vectors
-    let lhs_ret = self.lhs.return_value();
-    let rhs_ret = self.rhs.return_value();
-
-    // operators can only have instant vectors or scalars
-    if !lhs_ret.kind.is_operator_valid() {
-      return ReturnValue::unknown(
-        format!("lhs return type ({:?}) is not valid in an operator", &lhs_ret.kind),
-        self.clone().wrap()
-      );
+
+    /// Sets or replaces this Operator's Matching clause
+    pub fn matching(mut self, matching: Matching) -> Self {
+        self.matching = Some(matching);
+        self
     }
 
-    if !rhs_ret.kind.is_operator_valid() {
-      return ReturnValue::unknown(
-        format!("rhs return type ({:?}) is not valid in an operator", &rhs_ret.kind),
-        self.clone().wrap()
-      );
+    /// Clears this Operator's Matching clause, if any
+    pub fn clear_matching(mut self) -> Self {
+        self.matching = None;
+        self
     }
 
-    let kind;
-    let mut label_ops;
-
-    if lhs_ret.kind.is_scalar() && rhs_ret.kind.is_scalar() {
-      // scalar / scalar = scalar, otherwise instant vector
-      kind = ReturnKind::Scalar;
-      label_ops = vec![LabelSetOp::clear(self.clone().wrap(), self.span)];
-    } else if lhs_ret.kind.is_scalar() {
-      // lhs is scalar, so pull labels from the rhs
-      kind = ReturnKind::InstantVector;
-      label_ops = rhs_ret.label_ops;
-    } else if rhs_ret.kind.is_scalar() {
-      // rhs is scalar, so pull labels from the lhs
-      kind = ReturnKind::InstantVector;
-      label_ops = lhs_ret.label_ops;
-    } else {
-      kind = ReturnKind::InstantVector;
-
-      // neither side is scalar, so unless there's a matching clause with a
-      // group_*, the choice is arbitrary
-      // i.e. expressions without matching label sets will just return an empty
-      // set of metrics
-      
-      // on/ignoring clauses don't affect labels themselves, but a group_* may
-      if let Some(matching) = &self.matching {
-        if let Some(group) = &matching.group {
-          match &group.op {
-            MatchingGroupOp::Left => label_ops = lhs_ret.label_ops,
-            MatchingGroupOp::Right => label_ops = rhs_ret.label_ops
-          };
-
-          // any explicitly-specified labels are copied from the opposite side
-          // we don't care about the value, but it does imply that the label
-          // will exist in the output
-          label_ops.push(LabelSetOp::append(
-            self.clone().wrap(),
-            group.span,
-            group.labels.iter().cloned().collect(),
-          ));
-        } else {
-          label_ops = lhs_ret.label_ops;
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
+    }
+
+    /// Wraps this Operator in an Expression
+    pub fn wrap(self) -> Expression {
+        Expression::Operator(self)
+    }
+
+    pub fn return_value(&self) -> ReturnValue {
+        // note: largely based on the description from:
+        // https://www.robustperception.io/using-group_left-to-calculate-label-proportions
+
+        // binary operator exprs can only contain (and return) instant vectors
+        let lhs_ret = self.lhs.return_value();
+        let rhs_ret = self.rhs.return_value();
+
+        // operators can only have instant vectors or scalars
+        if !lhs_ret.kind.is_operator_valid() {
+            return ReturnValue::unknown(
+                format!(
+                    "lhs return type ({:?}) is not valid in an operator",
+                    &lhs_ret.kind
+                ),
+                self.clone().wrap(),
+            );
         }
-      } else {
-        label_ops = lhs_ret.label_ops;
-      }
-    };
 
-    ReturnValue { kind, label_ops }
-  }
+        if !rhs_ret.kind.is_operator_valid() {
+            return ReturnValue::unknown(
+                format!(
+                    "rhs return type ({:?}) is not valid in an operator",
+                    &rhs_ret.kind
+                ),
+                self.clone().wrap(),
+            );
+        }
+
+        let kind;
+        let mut label_ops;
+
+        if lhs_ret.kind.is_scalar() && rhs_ret.kind.is_scalar() {
+            // scalar / scalar = scalar, otherwise instant vector
+            kind = ReturnKind::Scalar;
+            label_ops = vec![LabelSetOp::clear(self.clone().wrap(), self.span)];
+        } else if lhs_ret.kind.is_scalar() {
+            // lhs is scalar, so pull labels from the rhs
+            kind = ReturnKind::InstantVector;
+            label_ops = rhs_ret.label_ops;
+        } else if rhs_ret.kind.is_scalar() {
+            // rhs is scalar, so pull labels from the lhs
+            kind = ReturnKind::InstantVector;
+            label_ops = lhs_ret.label_ops;
+        } else {
+            kind = ReturnKind::InstantVector;
+
+            // neither side is scalar, so unless there's a matching clause with a
+            // group_*, the choice is arbitrary
+            // i.e. expressions without matching label sets will just return an empty
+            // set of metrics
+
+            // on/ignoring clauses don't affect labels themselves, but a group_* may
+            if let Some(matching) = &self.matching {
+                if let Some(group) = &matching.group {
+                    match &group.op {
+                        MatchingGroupOp::Left => label_ops = lhs_ret.label_ops,
+                        MatchingGroupOp::Right => label_ops = rhs_ret.label_ops,
+                    };
+
+                    // any explicitly-specified labels are copied from the opposite side
+                    // we don't care about the value, but it does imply that the label
+                    // will exist in the output
+                    label_ops.push(LabelSetOp::append(
+                        self.clone().wrap(),
+                        group.span,
+                        group.labels.iter().cloned().collect(),
+                    ));
+                } else {
+                    label_ops = lhs_ret.label_ops;
+                }
+            } else {
+                label_ops = lhs_ret.label_ops;
+            }
+        };
+
+        ReturnValue { kind, label_ops }
+    }
 }
 
 impl fmt::Display for Operator {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{} {}", self.lhs, self.kind)?;
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} {}", self.lhs, self.kind)?;
 
-    if let Some(matching) = &self.matching {
-      write!(f, " {}", matching)?;
-    }
+        if let Some(matching) = &self.matching {
+            write!(f, " {}", matching)?;
+        }
 
-    write!(f, " {}", self.rhs)?;
+        write!(f, " {}", self.rhs)?;
 
-    Ok(())
-  }
+        Ok(())
+    }
 }
diff --git a/src/types/return_value.rs b/src/types/return_value.rs
index 28627f7..636b586 100644
--- a/src/types/return_value.rs
+++ b/src/types/return_value.rs
@@ -7,50 +7,50 @@ use super::misc::Span;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct UnknownCause {
-  /// An explanation for why this Unknown was returned
-  pub message: String,
+    /// An explanation for why this Unknown was returned
+    pub message: String,
 
-  // would be nice to make this a ref, but we run into wrapping issues
-  /// The expression that caused an Unknown to be returned
-  pub expression: Expression
+    // would be nice to make this a ref, but we run into wrapping issues
+    /// The expression that caused an Unknown to be returned
+    pub expression: Expression,
 }
 
 /// A predicted return datatype
 #[derive(Debug, PartialEq, Clone)]
 pub enum ReturnKind {
-  Unknown(Box<UnknownCause>),
-  Scalar,
-  String,
-  InstantVector,
-  RangeVector
+    Unknown(Box<UnknownCause>),
+    Scalar,
+    String,
+    InstantVector,
+    RangeVector,
 }
 
 impl ReturnKind {
-  pub fn unknown<S>(message: S, expression: Expression) -> Self
-  where
-    S: Into<String>
-  {
-    ReturnKind::Unknown(Box::new(UnknownCause {
-      message: message.into(),
-      expression
-    }))
-  }
-
-  /// Returns true if this `ReturnKind` is a valid sub-expression of an
-  /// operator, false if not.
-  pub fn is_operator_valid(&self) -> bool {
-    match self {
-      ReturnKind::Scalar | ReturnKind::InstantVector => true,
-      _ => false
+    pub fn unknown<S>(message: S, expression: Expression) -> Self
+    where
+        S: Into<String>,
+    {
+        ReturnKind::Unknown(Box::new(UnknownCause {
+            message: message.into(),
+            expression,
+        }))
     }
-  }
 
-  pub fn is_scalar(&self) -> bool {
-    match self {
-      ReturnKind::Scalar => true,
-      _ => false
+    /// Returns true if this `ReturnKind` is a valid sub-expression of an
+    /// operator, false if not.
+    pub fn is_operator_valid(&self) -> bool {
+        match self {
+            ReturnKind::Scalar | ReturnKind::InstantVector => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_scalar(&self) -> bool {
+        match self {
+            ReturnKind::Scalar => true,
+            _ => false,
+        }
     }
-  }
 }
 
 /// An operation on time series labels that might be performed by a particular
@@ -59,163 +59,166 @@ impl ReturnKind {
 /// An expression may perform more than one operation
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum LabelSetOp {
-  /// Convenience op that does nothing
-  NoOp,
+    /// Convenience op that does nothing
+    NoOp,
+
+    /// Clears all labels
+    Clear,
 
-  /// Clears all labels
-  Clear,
-  
-  /// Explicitly includes a set of labels in the output set
-  Append(HashSet<String>),
+    /// Explicitly includes a set of labels in the output set
+    Append(HashSet<String>),
 
-  /// Explicitly removes a set of labels from the output set
-  Remove(HashSet<String>),
+    /// Explicitly removes a set of labels from the output set
+    Remove(HashSet<String>),
 }
 
 impl LabelSetOp {
-  pub fn noop(expression: Expression, span: Option<Span>) -> LabelSetOpTuple {
-    LabelSetOpTuple {
-      op: LabelSetOp::NoOp,
-      expression,
-      span
+    pub fn noop(expression: Expression, span: Option<Span>) -> LabelSetOpTuple {
+        LabelSetOpTuple {
+            op: LabelSetOp::NoOp,
+            expression,
+            span,
+        }
     }
-  }
 
-  pub fn clear(expression: Expression, span: Option<Span>) -> LabelSetOpTuple {
-    LabelSetOpTuple {
-      op: LabelSetOp::Clear,
-      expression,
-      span
+    pub fn clear(expression: Expression, span: Option<Span>) -> LabelSetOpTuple {
+        LabelSetOpTuple {
+            op: LabelSetOp::Clear,
+            expression,
+            span,
+        }
     }
-  }
-
-  pub fn append(
-    expression: Expression, span: Option<Span>, labels: HashSet<String>
-  ) -> LabelSetOpTuple {
-    LabelSetOpTuple {
-      op: LabelSetOp::Append(labels),
-      expression,
-      span
+
+    pub fn append(
+        expression: Expression,
+        span: Option<Span>,
+        labels: HashSet<String>,
+    ) -> LabelSetOpTuple {
+        LabelSetOpTuple {
+            op: LabelSetOp::Append(labels),
+            expression,
+            span,
+        }
     }
-  }
-
-  pub fn remove(
-    expression: Expression, span: Option<Span>, labels: HashSet<String>
-  ) -> LabelSetOpTuple {
-    LabelSetOpTuple {
-      op: LabelSetOp::Remove(labels),
-      expression,
-      span,
+
+    pub fn remove(
+        expression: Expression,
+        span: Option<Span>,
+        labels: HashSet<String>,
+    ) -> LabelSetOpTuple {
+        LabelSetOpTuple {
+            op: LabelSetOp::Remove(labels),
+            expression,
+            span,
+        }
     }
-  }
 }
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct LabelSetOpTuple {
-  /// The label operation
-  pub op: LabelSetOp,
+    /// The label operation
+    pub op: LabelSetOp,
 
-  /// The expression that created this operation
-  pub expression: Expression,
+    /// The expression that created this operation
+    pub expression: Expression,
 
-  /// A span for the particular clause that created this operation
-  pub span: Option<Span>
+    /// A span for the particular clause that created this operation
+    pub span: Option<Span>,
 }
 
 #[derive(Debug, PartialEq, Clone)]
 /// A predicted return value from an expression
 pub struct ReturnValue {
-  pub kind: ReturnKind,
+    pub kind: ReturnKind,
 
-  /// A stack of operations applied to original source labels
-  pub label_ops: Vec<LabelSetOpTuple>
+    /// A stack of operations applied to original source labels
+    pub label_ops: Vec<LabelSetOpTuple>,
 }
 
 impl ReturnValue {
-  pub fn unknown<S>(message: S, expression: Expression) -> Self
-  where
-    S: Into<String>
-  {
-    ReturnValue {
-      kind: ReturnKind::unknown(message, expression),
-      label_ops: vec![]
-    }
-  }
-
-  pub fn label_op(&mut self, op: LabelSetOpTuple) -> &mut Self {
-    self.label_ops.push(op);
-
-    self
-  }
-
-  /// Given a number of input label keys, returns a set of labels expected to be
-  /// present on all returned time series
-  ///
-  /// Note that more labels may be returned than were provided in the input set;
-  /// expressions that explicitly select for or group on labels will 
-  pub fn passthrough(&self, input_labels: &[&str]) -> HashSet<String> {
-    let mut labels: HashSet<String> = HashSet::new();
-    labels.extend(input_labels.iter().map(|l| (*l).to_string()));
-
-    for set_op in &self.label_ops {
-      match &set_op.op {
-        LabelSetOp::NoOp => (),
-        LabelSetOp::Clear => labels.clear(),
-        LabelSetOp::Append(app) => {
-          labels = labels.union(&app).map(String::from).collect();
-        },
-        LabelSetOp::Remove(rem) => {
-          labels = labels.difference(&rem).map(String::from).collect();
+    pub fn unknown<S>(message: S, expression: Expression) -> Self
+    where
+        S: Into<String>,
+    {
+        ReturnValue {
+            kind: ReturnKind::unknown(message, expression),
+            label_ops: vec![],
         }
-      }
     }
 
-    labels
-  }
-
-  /// Determines the operation (plus expression and span) that caused the given
-  /// label to be dropped. If the label is never dropped, returns `None`.
-  ///
-  /// This also accounts for expressions that drop a label and re-add it later,
-  /// for instance with an aggregation clause.
-  pub fn drops(&self, label: &str) -> Option<&LabelSetOpTuple> {
-    let mut labels: HashSet<String> = HashSet::new();
-    labels.insert(label.to_string());
-
-    let mut ret_op = None;
-
-    for set_op in &self.label_ops {
-      match &set_op.op {
-        LabelSetOp::NoOp => (),
-        LabelSetOp::Clear => {
-          ret_op = Some(set_op);
-        },
-        LabelSetOp::Append(app) => {
-          // if this op re-adds a label, clear any previous op we thought
-          // might have removed it
-          if app.contains(label) {
-            ret_op = None;
-          }
-        },
-        LabelSetOp::Remove(rem) => {
-          // prefer any earlier op that already removed the label
-          if ret_op.is_none() && rem.contains(label) {
-            ret_op = Some(set_op);
-          }
+    pub fn label_op(&mut self, op: LabelSetOpTuple) -> &mut Self {
+        self.label_ops.push(op);
+
+        self
+    }
+
+    /// Given a number of input label keys, returns a set of labels expected to be
+    /// present on all returned time series
+    ///
+    /// Note that more labels may be returned than were provided in the input set;
+    /// expressions that explicitly select for or group on labels will
+    pub fn passthrough(&self, input_labels: &[&str]) -> HashSet<String> {
+        let mut labels: HashSet<String> = HashSet::new();
+        labels.extend(input_labels.iter().map(|l| (*l).to_string()));
+
+        for set_op in &self.label_ops {
+            match &set_op.op {
+                LabelSetOp::NoOp => (),
+                LabelSetOp::Clear => labels.clear(),
+                LabelSetOp::Append(app) => {
+                    labels = labels.union(&app).map(String::from).collect();
+                }
+                LabelSetOp::Remove(rem) => {
+                    labels = labels.difference(&rem).map(String::from).collect();
+                }
+            }
         }
-      }
+
+        labels
     }
 
-    ret_op
-  }
+    /// Determines the operation (plus expression and span) that caused the given
+    /// label to be dropped. If the label is never dropped, returns `None`.
+    ///
+    /// This also accounts for expressions that drop a label and re-add it later,
+    /// for instance with an aggregation clause.
+    pub fn drops(&self, label: &str) -> Option<&LabelSetOpTuple> {
+        let mut labels: HashSet<String> = HashSet::new();
+        labels.insert(label.to_string());
+
+        let mut ret_op = None;
+
+        for set_op in &self.label_ops {
+            match &set_op.op {
+                LabelSetOp::NoOp => (),
+                LabelSetOp::Clear => {
+                    ret_op = Some(set_op);
+                }
+                LabelSetOp::Append(app) => {
+                    // if this op re-adds a label, clear any previous op we thought
+                    // might have removed it
+                    if app.contains(label) {
+                        ret_op = None;
+                    }
+                }
+                LabelSetOp::Remove(rem) => {
+                    // prefer any earlier op that already removed the label
+                    if ret_op.is_none() && rem.contains(label) {
+                        ret_op = Some(set_op);
+                    }
+                }
+            }
+        }
+
+        ret_op
+    }
 }
 
 pub(crate) fn strs_to_set(strs: &[&str]) -> HashSet<String> {
-  let mut set: HashSet<String> = HashSet::new();
-  for s in strs {
-    set.insert((*s).to_string());
-  }
+    let mut set: HashSet<String> = HashSet::new();
+    for s in strs {
+        set.insert((*s).to_string());
+    }
 
-  set
+    set
 }
-
diff --git a/src/types/selector.rs b/src/types/selector.rs
index f0729c7..6fe3a27 100644
--- a/src/types/selector.rs
+++ b/src/types/selector.rs
@@ -11,241 +11,245 @@ use super::return_value::{LabelSetOp, ReturnKind, ReturnValue};
 /// Label equality operators
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum LabelOp {
-  Equal,
-  NotEqual,
-  RegexEqual,
-  RegexNotEqual
+    Equal,
+    NotEqual,
+    RegexEqual,
+    RegexNotEqual,
 }
 
 impl fmt::Display for LabelOp {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{}", match self {
-      LabelOp::Equal => "=",
-      LabelOp::NotEqual => "!=",
-      LabelOp::RegexEqual => "=~",
-      LabelOp::RegexNotEqual => "!~"
-    })
-  }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                LabelOp::Equal => "=",
+                LabelOp::NotEqual => "!=",
+                LabelOp::RegexEqual => "=~",
+                LabelOp::RegexNotEqual => "!~",
+            }
+        )
+    }
 }
 
 /// A label matcher in a selector
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Label {
-  pub key: String,
-  pub op: LabelOp,
-  pub value: String,
-  
-  pub span: Option<Span>
+    pub key: String,
+    pub op: LabelOp,
+    pub value: String,
+
+    pub span: Option<Span>,
 }
 
 impl Label {
-  pub fn new<S: Into<String>>(op: LabelOp, key: S, value: S) -> Self {
-    Label {
-      op,
-      key: key.into(),
-      value: value.into(),
-      span: None
-    }
-  }
-
-  pub fn equal<S: Into<String>>(key: S, value: S) -> Self {
-    Label::new(LabelOp::Equal, key, value)
-  }
-
-  pub fn not_equal<S: Into<String>>(key: S, value: S) -> Self {
-    Label::new(LabelOp::NotEqual, key, value)
-  }
-
-  pub fn regex_equal<S: Into<String>>(key: S, value: S) -> Self {
-    Label::new(LabelOp::RegexEqual, key, value)
-  }
-
-  pub fn regex_notequal<S: Into<String>>(key: S, value: S) -> Self {
-    Label::new(LabelOp::RegexNotEqual, key, value)
-  }
-
-  pub fn key<S: Into<String>>(mut self, key: S) -> Self {
-    self.key = key.into();
-    self
-  }
-
-  pub fn op(mut self, op: LabelOp) -> Self {
-    self.op = op;
-    self
-  }
-
-  pub fn value<S: Into<String>>(mut self, value: S) -> Self {
-    self.value = value.into();
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
+    pub fn new<S: Into<String>>(op: LabelOp, key: S, value: S) -> Self {
+        Label {
+            op,
+            key: key.into(),
+            value: value.into(),
+            span: None,
+        }
+    }
+
+    pub fn equal<S: Into<String>>(key: S, value: S) -> Self {
+        Label::new(LabelOp::Equal, key, value)
+    }
+
+    pub fn not_equal<S: Into<String>>(key: S, value: S) -> Self {
+        Label::new(LabelOp::NotEqual, key, value)
+    }
+
+    pub fn regex_equal<S: Into<String>>(key: S, value: S) -> Self {
+        Label::new(LabelOp::RegexEqual, key, value)
+    }
+
+    pub fn regex_notequal<S: Into<String>>(key: S, value: S) -> Self {
+        Label::new(LabelOp::RegexNotEqual, key, value)
+    }
+
+    pub fn key<S: Into<String>>(mut self, key: S) -> Self {
+        self.key = key.into();
+        self
+    }
+
+    pub fn op(mut self, op: LabelOp) -> Self {
+        self.op = op;
+        self
+    }
+
+    pub fn value<S: Into<String>>(mut self, value: S) -> Self {
+        self.value = value.into();
+        self
+    }
+
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
+    }
 }
 
 impl fmt::Display for Label {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    write!(f, "{}{}{:?}", self.key, self.op, self.value)
-  }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}{}{:?}", self.key, self.op, self.value)
+    }
 }
 
 /// A Selector that retrieves time series data from Prometheus
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
 pub struct Selector {
-  pub metric: Option<String>,
-  pub labels: Vec<Label>,
-  pub range: Option<PromDuration>,
-  pub offset: Option<PromDuration>,
-  pub subquery: Option<Subquery>,
+    pub metric: Option<String>,
+    pub labels: Vec<Label>,
+    pub range: Option<PromDuration>,
+    pub offset: Option<PromDuration>,
+    pub subquery: Option<Subquery>,
 
-  pub span: Option<Span>
+    pub span: Option<Span>,
 }
 
 impl Selector {
-  pub fn new() -> Self {
-    Selector {
-      metric: None,
-      labels: vec![],
-      range: None,
-      offset: None,
-      subquery: None,
-      span: None
-    }
-  }
-
-  /// Sets or replaces this Selector's metric
-  pub fn metric<S: Into<String>>(mut self, metric: S) -> Self {
-    self.metric = Some(metric.into());
-    self
-  }
-
-  /// Clears this Selector's metric
-  pub fn clear_metric(mut self) -> Self {
-    self.metric = None;
-    self
-  }
-
-  /// Adds a label to this Selector
-  pub fn label(mut self, label: Label) -> Self {
-    self.labels.push(label);
-    self
-  }
-
-  /// Replaces this Selector's labels with the given set
-  pub fn labels(mut self, labels: Vec<Label>) -> Self {
-    self.labels = labels;
-    self
-  }
-
-  /// Clears this Selector's set of labels
-  pub fn clear_labels(mut self) -> Self {
-    self.labels.clear();
-    self
-  }
-
-  /// Sets or replaces this Selector's range
-  pub fn range(mut self, range: PromDuration) -> Self {
-    self.range = Some(range);
-    self
-  }
-
-  /// Clears this Selector's range
-  pub fn clear_range(mut self) -> Self {
-    self.range = None;
-    self
-  }
-
-  /// Sets or replaces this Selector's offset
-  pub fn offset(mut self, offset: PromDuration) -> Self {
-    self.offset = Some(offset);
-    self
-  }
-
-  pub fn clear_offset(mut self) -> Self {
-    self.offset = None;
-    self
-  }
-
-  pub fn subquery(mut self, subquery: Subquery) -> Self {
-    self.subquery = Some(subquery);
-    self
-  }
-
-  pub fn clear_subquery(mut self) -> Self {
-    self.subquery = None;
-    self
-  }
-
-  pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
-    self.span = Some(span.into());
-    self
-  }
-
-  pub fn wrap(self) -> Expression {
-    Expression::Selector(self)
-  }
-
-  pub fn return_value(&self) -> ReturnValue {
-    let kind = match (self.range.is_some(), self.subquery.is_some()) {
-      (false, false) => ReturnKind::InstantVector,
-      (false, true) => ReturnKind::RangeVector,
-      (true, false) => ReturnKind::RangeVector,
-
-      // range + subquery is not allowed (however this is syntactically invalid)
-      (true, true) => ReturnKind::unknown(
-        "range and subquery are not allowed together",
-        self.clone().wrap()
-      )
-    };
-
-    // if a label is selected, we can infer that it must be present on the
-    // output vector
-    let mut label_ops = Vec::new();
-    if !self.labels.is_empty() {
-      label_ops.push(LabelSetOp::append(
-        self.clone().wrap(),
-        self.span,
-        HashSet::from_iter(self.labels.iter().cloned().map(|l| l.key))
-      ));
-    }
-
-    ReturnValue { kind, label_ops }
-  }
-}
-
-impl fmt::Display for Selector {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    if let Some(metric) = &self.metric {
-      write!(f, "{}", metric)?;
-    }
-    
-    if !self.labels.is_empty() {
-      write!(f, "{{")?;
-      for (i, label) in self.labels.iter().enumerate() {
-        if i > 0 {
-          write!(f, ",")?;
+    pub fn new() -> Self {
+        Selector {
+            metric: None,
+            labels: vec![],
+            range: None,
+            offset: None,
+            subquery: None,
+            span: None,
         }
+    }
+
+    /// Sets or replaces this Selector's metric
+    pub fn metric<S: Into<String>>(mut self, metric: S) -> Self {
+        self.metric = Some(metric.into());
+        self
+    }
 
-        write!(f, "{}", label)?;
-      }
+    /// Clears this Selector's metric
+    pub fn clear_metric(mut self) -> Self {
+        self.metric = None;
+        self
+    }
 
-      write!(f, "}}")?;
-    };
+    /// Adds a label to this Selector
+    pub fn label(mut self, label: Label) -> Self {
+        self.labels.push(label);
+        self
+    }
+
+    /// Replaces this Selector's labels with the given set
+    pub fn labels(mut self, labels: Vec<Label>) -> Self {
+        self.labels = labels;
+        self
+    }
 
-    if let Some(range) = &self.range {
-      write!(f, "[{}]", range)?;
+    /// Clears this Selector's set of labels
+    pub fn clear_labels(mut self) -> Self {
+        self.labels.clear();
+        self
     }
 
-    if let Some(offset) = &self.offset {
-      write!(f, " offset {}", offset)?;
+    /// Sets or replaces this Selector's range
+    pub fn range(mut self, range: PromDuration) -> Self {
+        self.range = Some(range);
+        self
     }
 
-    if let Some(subquery) = &self.subquery {
-      write!(f, "{}", subquery)?;
+    /// Clears this Selector's range
+    pub fn clear_range(mut self) -> Self {
+        self.range = None;
+        self
     }
 
-    Ok(())
-  }
+    /// Sets or replaces this Selector's offset
+    pub fn offset(mut self, offset: PromDuration) -> Self {
+        self.offset = Some(offset);
+        self
+    }
+
+    pub fn clear_offset(mut self) -> Self {
+        self.offset = None;
+        self
+    }
+
+    pub fn subquery(mut self, subquery: Subquery) -> Self {
+        self.subquery = Some(subquery);
+        self
+    }
+
+    pub fn clear_subquery(mut self) -> Self {
+        self.subquery = None;
+        self
+    }
+
+    pub fn span<S: Into<Span>>(mut self, span: S) -> Self {
+        self.span = Some(span.into());
+        self
+    }
+
+    pub fn wrap(self) -> Expression {
+        Expression::Selector(self)
+    }
+
+    pub fn return_value(&self) -> ReturnValue {
+        let kind = match (self.range.is_some(), self.subquery.is_some()) {
+            (false, false) => ReturnKind::InstantVector,
+            (false, true) => ReturnKind::RangeVector,
+            (true, false) => ReturnKind::RangeVector,
+
+            // range + subquery is not allowed (however this is syntactically invalid)
+            (true, true) => ReturnKind::unknown(
+                "range and subquery are not allowed together",
+                self.clone().wrap(),
+            ),
+        };
+
+        // if a label is selected, we can infer that it must be present on the
+        // output vector
+        let mut label_ops = Vec::new();
+        if !self.labels.is_empty() {
+            label_ops.push(LabelSetOp::append(
+                self.clone().wrap(),
+                self.span,
+                HashSet::from_iter(self.labels.iter().cloned().map(|l| l.key)),
+            ));
+        }
+
+        ReturnValue { kind, label_ops }
+    }
+}
+
+impl fmt::Display for Selector {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(metric) = &self.metric {
+            write!(f, "{}", metric)?;
+        }
+
+        if !self.labels.is_empty() {
+            write!(f, "{{")?;
+            for (i, label) in self.labels.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ",")?;
+                }
+
+                write!(f, "{}", label)?;
+            }
+
+            write!(f, "}}")?;
+        };
+
+        if let Some(range) = &self.range {
+            write!(f, "[{}]", range)?;
+        }
+
+        if let Some(offset) = &self.offset {
+            write!(f, " offset {}", offset)?;
+        }
+
+        if let Some(subquery) = &self.subquery {
+            write!(f, "{}", subquery)?;
+        }
+
+        Ok(())
+    }
 }
diff --git a/tests/label_passthrough.rs b/tests/label_passthrough.rs
index 450aa8c..67457fa 100644
--- a/tests/label_passthrough.rs
+++ b/tests/label_passthrough.rs
@@ -7,175 +7,193 @@ use prometheus_parser::*;
 
 #[test]
 fn passthrough_trivial_empty() -> Result<()> {
-  assert_eq!(
-    parse_expr("foo")?.return_value().passthrough(&[]),
-    hashset!{}
-  );
+    assert_eq!(
+        parse_expr("foo")?.return_value().passthrough(&[]),
+        hashset! {}
+    );
 
-  Ok(())
+    Ok(())
 }
 
 #[test]
 fn passthrough_trivial_label() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"foo{bar="baz"}"#)?.return_value().passthrough(&[]),
-    hashset!{"bar".to_string()}
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr(r#"foo{bar="baz"}"#)?
+            .return_value()
+            .passthrough(&[]),
+        hashset! {"bar".to_string()}
+    );
+
+    Ok(())
 }
 
 #[test]
 fn passthrough_trivial_user() -> Result<()> {
-  assert_eq!(
-    parse_expr("foo")?.return_value().passthrough(&["bar"]),
-    hashset!{"bar".to_string()}
-  );
+    assert_eq!(
+        parse_expr("foo")?.return_value().passthrough(&["bar"]),
+        hashset! {"bar".to_string()}
+    );
 
-  Ok(())
+    Ok(())
 }
 
 #[test]
 fn passthrough_trivial_both() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"foo{bar="baz"}"#)?.return_value().passthrough(&["qux"]),
-    hashset!{"bar".to_string(), "qux".to_string()}
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr(r#"foo{bar="baz"}"#)?
+            .return_value()
+            .passthrough(&["qux"]),
+        hashset! {"bar".to_string(), "qux".to_string()}
+    );
+
+    Ok(())
 }
 
 #[test]
 fn passthrough_grouping() -> Result<()> {
-  // non-aggregation functions don't clear labels...
-  assert_eq!(
-    parse_expr(r#"zxcv(foo{bar="a"})"#)?.return_value().passthrough(&["baz"]),
-    hashset!{"bar".to_string(), "baz".to_string()}
-  );
-
-  // ... but actual aggregations do
-  assert_eq!(
-    parse_expr(r#"sum(foo{bar="a"})"#)?.return_value().passthrough(&["baz"]),
-    hashset!{}
-  );
-
-  assert_eq!(
-    parse_expr(r#"sum(foo{bar="a"}) by (baz)"#)?
-      .return_value()
-      .passthrough(&["baz"]),
-    hashset!{"baz".to_string()}
-  );
-
-  assert_eq!(
-    parse_expr(r#"sum(foo{bar="a"}) without (qux)"#)?
-      .return_value()
-      .passthrough(&["baz"]),
-    hashset!{"bar".to_string(), "baz".to_string()}
-  );
-
-  Ok(())
+    // non-aggregation functions don't clear labels...
+    assert_eq!(
+        parse_expr(r#"zxcv(foo{bar="a"})"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {"bar".to_string(), "baz".to_string()}
+    );
+
+    // ... but actual aggregations do
+    assert_eq!(
+        parse_expr(r#"sum(foo{bar="a"})"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {}
+    );
+
+    assert_eq!(
+        parse_expr(r#"sum(foo{bar="a"}) by (baz)"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {"baz".to_string()}
+    );
+
+    assert_eq!(
+        parse_expr(r#"sum(foo{bar="a"}) without (qux)"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {"bar".to_string(), "baz".to_string()}
+    );
+
+    Ok(())
 }
 
 #[test]
 fn passthrough_grouping_operator() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"foo + bar"#)?.return_value().passthrough(&["baz"]),
-    hashset!{"baz".to_string()}
-  );
-
-  assert_eq!(
-    parse_expr(r#"sum(foo) + bar"#)?.return_value().passthrough(&["baz"]),
-    hashset!{}
-  );
-
-  assert_eq!(
-    parse_expr(r#"sum(foo) by (baz) + bar"#)?
-      .return_value()
-      .passthrough(&["baz"]),
-    hashset!{"baz".to_string()}
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr(r#"foo + bar"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {"baz".to_string()}
+    );
+
+    assert_eq!(
+        parse_expr(r#"sum(foo) + bar"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {}
+    );
+
+    assert_eq!(
+        parse_expr(r#"sum(foo) by (baz) + bar"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {"baz".to_string()}
+    );
+
+    Ok(())
 }
 
 #[test]
 fn passthrough_matching() -> Result<()> {
-  // these are likely impossible prometheus expressions (or at least, could
-  // never return any results), but are concise enough tests
-  assert_eq!(
-    parse_expr(r#"foo{bar="a"} / on(foo) group_left bar{baz="b"}"#)?
-      .return_value()
-      .passthrough(&["qux"]),
-    hashset!{"bar".to_string(), "qux".to_string()}
-  );
-
-  assert_eq!(
-    parse_expr(r#"foo{bar="a"} / on(foo) group_right bar{baz="b"}"#)?
-      .return_value()
-      .passthrough(&["qux"]),
-    hashset!{"baz".to_string(), "qux".to_string()}
-  );
-
-  assert_eq!(
-    parse_expr(r#"foo{bar="a"} / on(foo) group_left(baz) bar{baz="b"}"#)?
-      .return_value()
-      .passthrough(&["qux"]),
-    hashset!{"bar".to_string(), "baz".to_string(), "qux".to_string()}
-  );
-
-  Ok(())
+    // these are likely impossible prometheus expressions (or at least, could
+    // never return any results), but are concise enough tests
+    assert_eq!(
+        parse_expr(r#"foo{bar="a"} / on(foo) group_left bar{baz="b"}"#)?
+            .return_value()
+            .passthrough(&["qux"]),
+        hashset! {"bar".to_string(), "qux".to_string()}
+    );
+
+    assert_eq!(
+        parse_expr(r#"foo{bar="a"} / on(foo) group_right bar{baz="b"}"#)?
+            .return_value()
+            .passthrough(&["qux"]),
+        hashset! {"baz".to_string(), "qux".to_string()}
+    );
+
+    assert_eq!(
+        parse_expr(r#"foo{bar="a"} / on(foo) group_left(baz) bar{baz="b"}"#)?
+            .return_value()
+            .passthrough(&["qux"]),
+        hashset! {"bar".to_string(), "baz".to_string(), "qux".to_string()}
+    );
+
+    Ok(())
 }
 
 #[test]
 fn passthrough_special() -> Result<()> {
-  // no arg scalar function
-  assert_eq!(
-    parse_expr(r#"time()"#)?.return_value().passthrough(&["baz"]),
-    hashset!{}
-  );
-
-  // weird 2nd arg functions
-  // histogram_quantile also implies an `le` label
-  assert_eq!(
-    parse_expr(r#"histogram_quantile(0.9, rate(foo[5m]))"#)?
-      .return_value()
-      .passthrough(&["baz"]),
-    hashset!{"baz".to_string(), "le".to_string()}
-  );
-
-  assert_eq!(
-    parse_expr(r#"quantile_over_time(0.9, rate(foo[5m]))"#)?
-      .return_value()
-      .passthrough(&["baz"]),
-    hashset!{"baz".to_string()}
-  );
-
-  // https://prometheus.io/docs/prometheus/latest/querying/functions/#label_join
-  assert_eq!(
-    parse_expr(r#"label_join(
+    // no arg scalar function
+    assert_eq!(
+        parse_expr(r#"time()"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {}
+    );
+
+    // weird 2nd arg functions
+    // histogram_quantile also implies an `le` label
+    assert_eq!(
+        parse_expr(r#"histogram_quantile(0.9, rate(foo[5m]))"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {"baz".to_string(), "le".to_string()}
+    );
+
+    assert_eq!(
+        parse_expr(r#"quantile_over_time(0.9, rate(foo[5m]))"#)?
+            .return_value()
+            .passthrough(&["baz"]),
+        hashset! {"baz".to_string()}
+    );
+
+    // https://prometheus.io/docs/prometheus/latest/querying/functions/#label_join
+    assert_eq!(
+        parse_expr(
+            r#"label_join(
       up{job="api-server",src1="a",src2="b",src3="c"},
       "foo", ",", "src1", "src2", "src3"
-    )"#)?
-      .return_value()
-      .passthrough(&[]),
-    hashset!{
-      "job".to_string(), "src1".to_string(), "src2".to_string(),
-      "src3".to_string(), "foo".to_string()
-    }
-  );
-
-  // https://prometheus.io/docs/prometheus/latest/querying/functions/#label_replace
-  assert_eq!(
-    parse_expr(r#"label_replace(
+    )"#
+        )?
+        .return_value()
+        .passthrough(&[]),
+        hashset! {
+          "job".to_string(), "src1".to_string(), "src2".to_string(),
+          "src3".to_string(), "foo".to_string()
+        }
+    );
+
+    // https://prometheus.io/docs/prometheus/latest/querying/functions/#label_replace
+    assert_eq!(
+        parse_expr(
+            r#"label_replace(
       up{job="api-server",service="a:c"},
        "foo", "$1", "service", "(.*):.*"
-    )"#)?
-      .return_value()
-      .passthrough(&[]),
-    hashset!{
-      "job".to_string(), "service".to_string(), "foo".to_string()
-    }
-  );
-
-  Ok(())
+    )"#
+        )?
+        .return_value()
+        .passthrough(&[]),
+        hashset! {
+          "job".to_string(), "service".to_string(), "foo".to_string()
+        }
+    );
+
+    Ok(())
 }
diff --git a/tests/simple.rs b/tests/simple.rs
index 38d40a1..f163051 100644
--- a/tests/simple.rs
+++ b/tests/simple.rs
@@ -6,541 +6,611 @@ use prometheus_parser::*;
 
 #[test]
 fn parse_greater_than() -> Result<()> {
-  assert_eq!(
-    parse_expr("foo > bar")?,
-    Operator::new(
-      OperatorKind::GreaterThan,
-      Selector::new().metric("foo").span((0, 3)).wrap(),
-      Selector::new().metric("bar").span((6, 9)).wrap()
-    ).span((3, 6)).wrap()
-  );
-
-  assert_ne!(
-    parse_expr("foo < bar")?,
-    Operator::new(
-      OperatorKind::GreaterThan,
-      Selector::new().metric("foo").span((0, 3)).wrap(),
-      Selector::new().metric("bar").span((6, 9)).wrap()
-    ).span((3, 6)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("foo > bar")?,
+        Operator::new(
+            OperatorKind::GreaterThan,
+            Selector::new().metric("foo").span((0, 3)).wrap(),
+            Selector::new().metric("bar").span((6, 9)).wrap()
+        )
+        .span((3, 6))
+        .wrap()
+    );
+
+    assert_ne!(
+        parse_expr("foo < bar")?,
+        Operator::new(
+            OperatorKind::GreaterThan,
+            Selector::new().metric("foo").span((0, 3)).wrap(),
+            Selector::new().metric("bar").span((6, 9)).wrap()
+        )
+        .span((3, 6))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_whitespace() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"
+    assert_eq!(
+        parse_expr(
+            r#"
       foo
       >
       bar
-    "#)?,
-    Operator::new(
-      OperatorKind::GreaterThan,
-      Selector::new().metric("foo").span((7, 10)).wrap(),
-      Selector::new().metric("bar").span((25, 28)).wrap()
-    ).span((10, 25)).wrap()
-  );
-
-  Ok(())
+    "#
+        )?,
+        Operator::new(
+            OperatorKind::GreaterThan,
+            Selector::new().metric("foo").span((7, 10)).wrap(),
+            Selector::new().metric("bar").span((25, 28)).wrap()
+        )
+        .span((10, 25))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_less_than() -> Result<()> {
-  assert_ne!(   // set to assert not equal
-    parse_expr("foo > bar")?,
-    Operator::new(
-      OperatorKind::LessThan,
-      Selector::new().metric("foo").span((0, 3)).wrap(),
-      Selector::new().metric("bar").span((6, 9)).wrap()
-    ).span((3, 6)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("foo < bar")?,
-    Operator::new(
-      OperatorKind::LessThan,
-      Selector::new().metric("foo").span((0, 3)).wrap(),
-      Selector::new().metric("bar").span((6, 9)).wrap()
-    ).span((3, 6)).wrap()
-  );
-
-  Ok(())
+    assert_ne!(
+        // set to assert not equal
+        parse_expr("foo > bar")?,
+        Operator::new(
+            OperatorKind::LessThan,
+            Selector::new().metric("foo").span((0, 3)).wrap(),
+            Selector::new().metric("bar").span((6, 9)).wrap()
+        )
+        .span((3, 6))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("foo < bar")?,
+        Operator::new(
+            OperatorKind::LessThan,
+            Selector::new().metric("foo").span((0, 3)).wrap(),
+            Selector::new().metric("bar").span((6, 9)).wrap()
+        )
+        .span((3, 6))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_add() -> Result<()> {
-  assert_eq!(
-    parse_expr("foo + bar")?,
-    Operator::new(
-      OperatorKind::Add,
-      Selector::new().metric("foo").span((0, 3)).wrap(),
-      Selector::new().metric("bar").span((6, 9)).wrap()
-    ).span((3, 6)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("foo + bar")?,
+        Operator::new(
+            OperatorKind::Add,
+            Selector::new().metric("foo").span((0, 3)).wrap(),
+            Selector::new().metric("bar").span((6, 9)).wrap()
+        )
+        .span((3, 6))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_equal() -> Result<()> {
-  assert_eq!(
-    parse_expr("foo == bar")?,
-    Operator::new(
-      OperatorKind::Equal,
-      Selector::new().metric("foo").span((0, 3)).wrap(),
-      Selector::new().metric("bar").span((7, 10)).wrap()
-    ).span((3, 7)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("foo == bar")?,
+        Operator::new(
+            OperatorKind::Equal,
+            Selector::new().metric("foo").span((0, 3)).wrap(),
+            Selector::new().metric("bar").span((7, 10)).wrap()
+        )
+        .span((3, 7))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_not_equal() -> Result<()> {
-  assert_eq!(
-    parse_expr("foo != foo")?,
-    Operator::new(
-      OperatorKind::NotEqual,
-      Selector::new().metric("foo").span((0, 3)).wrap(),
-      Selector::new().metric("foo").span((7, 10)).wrap()
-    ).span((3, 7)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("foo != foo")?,
+        Operator::new(
+            OperatorKind::NotEqual,
+            Selector::new().metric("foo").span((0, 3)).wrap(),
+            Selector::new().metric("foo").span((7, 10)).wrap()
+        )
+        .span((3, 7))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_power() -> Result<()> {
-  assert_eq!(
-    parse_expr("check ^ taco")?,
-    Operator::new(
-      OperatorKind::Power,
-      Selector::new().metric("check").span((0, 5)).wrap(),
-      Selector::new().metric("taco").span((8, 12)).wrap()
-    ).span((5, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("check ^ taco")?,
+        Operator::new(
+            OperatorKind::Power,
+            Selector::new().metric("check").span((0, 5)).wrap(),
+            Selector::new().metric("taco").span((8, 12)).wrap()
+        )
+        .span((5, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_multiply() -> Result<()> {
-  assert_eq!(
-    parse_expr("check * value")?,
-    Operator::new(
-      OperatorKind::Multiply,
-      Selector::new().metric("check").span((0, 5)).wrap(),
-      Selector::new().metric("value").span((8, 13)).wrap()
-    ).span((5, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("check * value")?,
+        Operator::new(
+            OperatorKind::Multiply,
+            Selector::new().metric("check").span((0, 5)).wrap(),
+            Selector::new().metric("value").span((8, 13)).wrap()
+        )
+        .span((5, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_divide() -> Result<()> {
-  assert_eq!(
-    parse_expr("check / value")?,
-    Operator::new(
-      OperatorKind::Divide,
-      Selector::new().metric("check").span((0, 5)).wrap(),
-      Selector::new().metric("value").span((8, 13)).wrap()
-    ).span((5, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("check / value")?,
+        Operator::new(
+            OperatorKind::Divide,
+            Selector::new().metric("check").span((0, 5)).wrap(),
+            Selector::new().metric("value").span((8, 13)).wrap()
+        )
+        .span((5, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_modulo() -> Result<()> {
-  assert_eq!(
-    parse_expr("check % value")?,
-    Operator::new(
-      OperatorKind::Modulo,
-      Selector::new().metric("check").span((0, 5)).wrap(),
-      Selector::new().metric("value").span((8, 13)).wrap()
-    ).span((5, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("check % value")?,
+        Operator::new(
+            OperatorKind::Modulo,
+            Selector::new().metric("check").span((0, 5)).wrap(),
+            Selector::new().metric("value").span((8, 13)).wrap()
+        )
+        .span((5, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_subtract() -> Result<()> {
-  assert_eq!(
-    parse_expr("check - value")?,
-    Operator::new(
-      OperatorKind::Subtract,
-      Selector::new().metric("check").span((0, 5)).wrap(),
-      Selector::new().metric("value").span((8, 13)).wrap()
-    ).span((5, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("check - value")?,
+        Operator::new(
+            OperatorKind::Subtract,
+            Selector::new().metric("check").span((0, 5)).wrap(),
+            Selector::new().metric("value").span((8, 13)).wrap()
+        )
+        .span((5, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_less_than_equal() -> Result<()> {
-  assert_eq!(
-    parse_expr("this <= that")?,
-    Operator::new(
-      OperatorKind::LessThanEqual,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((8, 12)).wrap()
-    ).span((4, 8)).wrap()
-  );
-
-  assert_ne!(
-    parse_expr("this >= that")?,
-    Operator::new(
-      OperatorKind::LessThanEqual,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((8, 12)).wrap()
-    ).span((4, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("this <= that")?,
+        Operator::new(
+            OperatorKind::LessThanEqual,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((8, 12)).wrap()
+        )
+        .span((4, 8))
+        .wrap()
+    );
+
+    assert_ne!(
+        parse_expr("this >= that")?,
+        Operator::new(
+            OperatorKind::LessThanEqual,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((8, 12)).wrap()
+        )
+        .span((4, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_greater_than_equal() -> Result<()> {
-  assert_eq!(
-    parse_expr("this >= that")?,
-    Operator::new(
-      OperatorKind::GreaterThanEqual,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((8, 12)).wrap()
-    ).span((4, 8)).wrap()
-  );
-
-  assert_ne!(
-    parse_expr("this <= that")?,
-    Operator::new(
-      OperatorKind::GreaterThanEqual,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((8, 12)).wrap()
-    ).span((4, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("this >= that")?,
+        Operator::new(
+            OperatorKind::GreaterThanEqual,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((8, 12)).wrap()
+        )
+        .span((4, 8))
+        .wrap()
+    );
+
+    assert_ne!(
+        parse_expr("this <= that")?,
+        Operator::new(
+            OperatorKind::GreaterThanEqual,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((8, 12)).wrap()
+        )
+        .span((4, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_and() -> Result<()> {
-  assert_eq!(
-    parse_expr("this and that")?,
-    Operator::new(
-      OperatorKind::And,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((9, 13)).wrap()
-    ).span((4, 9)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this And that")?,
-    Operator::new(
-      OperatorKind::And,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((9, 13)).wrap()
-    ).span((4, 9)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this AND that")?,
-    Operator::new(
-      OperatorKind::And,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((9, 13)).wrap()
-    ).span((4, 9)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("this and that")?,
+        Operator::new(
+            OperatorKind::And,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((9, 13)).wrap()
+        )
+        .span((4, 9))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this And that")?,
+        Operator::new(
+            OperatorKind::And,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((9, 13)).wrap()
+        )
+        .span((4, 9))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this AND that")?,
+        Operator::new(
+            OperatorKind::And,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((9, 13)).wrap()
+        )
+        .span((4, 9))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_or() -> Result<()> {
-  assert_eq!(
-    parse_expr("this or that")?,
-    Operator::new(
-      OperatorKind::Or,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((8, 12)).wrap()
-    ).span((4, 8)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this Or that")?,
-    Operator::new(
-      OperatorKind::Or,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((8, 12)).wrap()
-    ).span((4, 8)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this OR that")?,
-    Operator::new(
-      OperatorKind::Or,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((8, 12)).wrap()
-    ).span((4, 8)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("this or that")?,
+        Operator::new(
+            OperatorKind::Or,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((8, 12)).wrap()
+        )
+        .span((4, 8))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this Or that")?,
+        Operator::new(
+            OperatorKind::Or,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((8, 12)).wrap()
+        )
+        .span((4, 8))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this OR that")?,
+        Operator::new(
+            OperatorKind::Or,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((8, 12)).wrap()
+        )
+        .span((4, 8))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_unless() -> Result<()> {
-  assert_eq!(
-    parse_expr("this unless that")?,
-    Operator::new(
-      OperatorKind::Unless,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((12, 16)).wrap()
-    ).span((4, 12)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this Unless that")?,
-    Operator::new(
-      OperatorKind::Unless,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((12, 16)).wrap()
-    ).span((4, 12)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this UNLESS that")?,
-    Operator::new(
-      OperatorKind::Unless,
-      Selector::new().metric("this").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((12, 16)).wrap()
-    ).span((4, 12)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("this unless that")?,
+        Operator::new(
+            OperatorKind::Unless,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((12, 16)).wrap()
+        )
+        .span((4, 12))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this Unless that")?,
+        Operator::new(
+            OperatorKind::Unless,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((12, 16)).wrap()
+        )
+        .span((4, 12))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this UNLESS that")?,
+        Operator::new(
+            OperatorKind::Unless,
+            Selector::new().metric("this").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((12, 16)).wrap()
+        )
+        .span((4, 12))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_parentheses() -> Result<()> {
-  assert_eq!(
-    parse_expr("(f) > bar")?,   // "()" need .group() and to be removed from the .span() item
-    Operator::new(
-      OperatorKind::GreaterThan,
-      Group::new(
-        Selector::new().metric("f").span((1, 2)).wrap()
-      ).span((0, 3)).wrap(),
-      Selector::new().metric("bar").span((6, 9)).wrap()
-    ).span((3, 6)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("(some)+(more)")?,
-    Operator::new(
-      OperatorKind::Add,
-      Group::new(
-        Selector::new().metric("some").span((1, 5)).wrap()
-      ).span((0, 6)).wrap(),
-      Group::new(
-        Selector::new().metric("more").span((8, 12)).wrap()
-      ).span((7, 13)).wrap(),
-    ).span((6, 7)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("(f) > bar")?, // "()" need .group() and to be removed from the .span() item
+        Operator::new(
+            OperatorKind::GreaterThan,
+            Group::new(Selector::new().metric("f").span((1, 2)).wrap())
+                .span((0, 3))
+                .wrap(),
+            Selector::new().metric("bar").span((6, 9)).wrap()
+        )
+        .span((3, 6))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("(some)+(more)")?,
+        Operator::new(
+            OperatorKind::Add,
+            Group::new(Selector::new().metric("some").span((1, 5)).wrap())
+                .span((0, 6))
+                .wrap(),
+            Group::new(Selector::new().metric("more").span((8, 12)).wrap())
+                .span((7, 13))
+                .wrap(),
+        )
+        .span((6, 7))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_colon() -> Result<()> {
-  assert_eq!(
-    parse_expr("t::s and that")?,
-    Operator::new(
-      OperatorKind::And,
-      Selector::new().metric("t::s").span((0, 4)).wrap(),
-      Selector::new().metric("that").span((9, 13)).wrap()
-    ).span((4, 9)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this:or:that:+:this:or:that")?,
-    Operator::new(
-      OperatorKind::Add,
-      Selector::new().metric("this:or:that:").span((0, 13)).wrap(),
-      Selector::new().metric(":this:or:that").span((14, 27)).wrap()
-    ).span((13, 14)).wrap()
-  );
-
-  assert_eq!(
-    parse_expr("this:+:that")?,
-    Operator::new(
-      OperatorKind::Add,
-      Selector::new().metric("this:").span((0, 5)).wrap(),
-      Selector::new().metric(":that").span((6, 11)).wrap()
-    ).span((5, 6)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr("t::s and that")?,
+        Operator::new(
+            OperatorKind::And,
+            Selector::new().metric("t::s").span((0, 4)).wrap(),
+            Selector::new().metric("that").span((9, 13)).wrap()
+        )
+        .span((4, 9))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this:or:that:+:this:or:that")?,
+        Operator::new(
+            OperatorKind::Add,
+            Selector::new().metric("this:or:that:").span((0, 13)).wrap(),
+            Selector::new()
+                .metric(":this:or:that")
+                .span((14, 27))
+                .wrap()
+        )
+        .span((13, 14))
+        .wrap()
+    );
+
+    assert_eq!(
+        parse_expr("this:+:that")?,
+        Operator::new(
+            OperatorKind::Add,
+            Selector::new().metric("this:").span((0, 5)).wrap(),
+            Selector::new().metric(":that").span((6, 11)).wrap()
+        )
+        .span((5, 6))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_missing_quotation() -> std::result::Result<(), ()> {
-  match parse_expr(r#"hello{world="jupiter",type="gas}"#) {
-    Err(_) => Ok(()),
-    _ => Err(())
-  }
+    match parse_expr(r#"hello{world="jupiter",type="gas}"#) {
+        Err(_) => Ok(()),
+        _ => Err(()),
+    }
 }
 
 #[test]
 fn parse_missing_rhs() -> std::result::Result<(), ()> {
-  match parse_expr(r#"hello{world="jupiter",type="gas"} !="#) {
-    Err(_) => Ok(()),
-    _ => Err(())
-  }
+    match parse_expr(r#"hello{world="jupiter",type="gas"} !="#) {
+        Err(_) => Ok(()),
+        _ => Err(()),
+    }
 }
 
 #[test]
 fn parse_trailing_comma() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"hello{world="jupiter",type="gas",}"#)?,
-    Selector::new()
-      .metric("hello")
-      .label(Label::equal("world", "jupiter").span((6, 21)))
-      .label(Label::equal("type", "gas").span((22, 32)))
-      .span((0, 34))
-      .wrap()
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr(r#"hello{world="jupiter",type="gas",}"#)?,
+        Selector::new()
+            .metric("hello")
+            .label(Label::equal("world", "jupiter").span((6, 21)))
+            .label(Label::equal("type", "gas").span((22, 32)))
+            .span((0, 34))
+            .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_comment() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"
+    assert_eq!(
+        parse_expr(
+            r#"
       foo # lorem
       +   # ipsum
       bar # dolor
-    "#)?,
-    Operator::new(
-      OperatorKind::Add,
-      Selector::new().metric("foo").span((7, 10)).wrap(),
-      Selector::new().metric("bar").span((43, 46)).wrap()
-    ).span((10, 43)).wrap()
-  );
-
-  Ok(())
+    "#
+        )?,
+        Operator::new(
+            OperatorKind::Add,
+            Selector::new().metric("foo").span((7, 10)).wrap(),
+            Selector::new().metric("bar").span((43, 46)).wrap()
+        )
+        .span((10, 43))
+        .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_weird_floats() -> Result<()> {
-  // nan != nan, so gotta check in a roundabout way
-  match parse_expr("NaN + 1")? {
-    Expression::Operator(o) => match *o.lhs {
-      Expression::Float(f) => assert!(f.is_nan(), "must be NaN"),
-      _ => assert!(false, "must be float")
-    },
-    _ => assert!(false, "must be operator")
-  }
-
-  match parse_expr("+NaN + +1")? {
-    Expression::Operator(o) => {
-      match *o.lhs {
-        Expression::Float(f) => assert!(f.is_nan(), "must be NaN"),
-        _ => assert!(false, "must be float")
-      }
-
-      match *o.rhs {
-        Expression::Float(f) => assert_eq!(f, 1.0),
-        _ => assert!(false, "must be float")
-      }
-    },
-    _ => assert!(false, "must be operator")
-  }
-
-  match parse_expr("Inf + -1")? {
-    Expression::Operator(o) => {
-      match *o.lhs {
-        Expression::Float(f) => assert!(
-          f.is_infinite() && f.is_sign_positive(),
-          "must be +inf"
-        ),
-        _ => assert!(false, "must be float")
-      }
-      
-      match *o.rhs {
-        Expression::Float(f) => assert_eq!(f, -1.0),
-        _ => assert!(false, "must be float")
-      }
-    },
-    _ => assert!(false, "must be operator")
-  }
-
-  match parse_expr("+Inf + -.1")? {
-    Expression::Operator(o) => {
-      match *o.lhs {
-        Expression::Float(f) => assert!(
-          f.is_infinite() && f.is_sign_positive(),
-          "must be +inf"
-        ),
-        _ => assert!(false, "must be float")
-      }
-
-      match *o.rhs {
-        Expression::Float(f) => assert_eq!(f, -0.1),
-        _ => assert!(false, "must be float")
-      }
-    },
-    _ => assert!(false, "must be operator")
-  }
-
-  match parse_expr("-Inf + 1")? {
-    Expression::Operator(o) => match *o.lhs {
-      Expression::Float(f) => assert!(f.is_infinite() && f.is_sign_negative()),
-      _ => assert!(false, "must be float")
-    },
-    _ => assert!(false, "must be operator")
-  }
-
-  Ok(())
+    // nan != nan, so gotta check in a roundabout way
+    match parse_expr("NaN + 1")? {
+        Expression::Operator(o) => match *o.lhs {
+            Expression::Float(f) => assert!(f.is_nan(), "must be NaN"),
+            _ => assert!(false, "must be float"),
+        },
+        _ => assert!(false, "must be operator"),
+    }
+
+    match parse_expr("+NaN + +1")? {
+        Expression::Operator(o) => {
+            match *o.lhs {
+                Expression::Float(f) => assert!(f.is_nan(), "must be NaN"),
+                _ => assert!(false, "must be float"),
+            }
+
+            match *o.rhs {
+                Expression::Float(f) => assert_eq!(f, 1.0),
+                _ => assert!(false, "must be float"),
+            }
+        }
+        _ => assert!(false, "must be operator"),
+    }
+
+    match parse_expr("Inf + -1")? {
+        Expression::Operator(o) => {
+            match *o.lhs {
+                Expression::Float(f) => {
+                    assert!(f.is_infinite() && f.is_sign_positive(), "must be +inf")
+                }
+                _ => assert!(false, "must be float"),
+            }
+
+            match *o.rhs {
+                Expression::Float(f) => assert_eq!(f, -1.0),
+                _ => assert!(false, "must be float"),
+            }
+        }
+        _ => assert!(false, "must be operator"),
+    }
+
+    match parse_expr("+Inf + -.1")? {
+        Expression::Operator(o) => {
+            match *o.lhs {
+                Expression::Float(f) => {
+                    assert!(f.is_infinite() && f.is_sign_positive(), "must be +inf")
+                }
+                _ => assert!(false, "must be float"),
+            }
+
+            match *o.rhs {
+                Expression::Float(f) => assert_eq!(f, -0.1),
+                _ => assert!(false, "must be float"),
+            }
+        }
+        _ => assert!(false, "must be operator"),
+    }
+
+    match parse_expr("-Inf + 1")? {
+        Expression::Operator(o) => match *o.lhs {
+            Expression::Float(f) => assert!(f.is_infinite() && f.is_sign_negative()),
+            _ => assert!(false, "must be float"),
+        },
+        _ => assert!(false, "must be operator"),
+    }
+
+    Ok(())
 }
 
 #[test]
 fn parse_scientific_notation_floats() -> Result<()> {
     match parse_expr("1e1")? {
-      Expression::Float(f) => assert_eq!(f, (1e1 as f64)),
-      _ => assert!(false, "must be a float")
+        Expression::Float(f) => assert_eq!(f, (1e1 as f64)),
+        _ => assert!(false, "must be a float"),
     };
 
     match parse_expr("1e-1")? {
-      Expression::Float(f) => assert_eq!(f, (1e-1 as f64)),
-      _ => assert!(false, "must be a float")
+        Expression::Float(f) => assert_eq!(f, (1e-1 as f64)),
+        _ => assert!(false, "must be a float"),
     };
 
     match parse_expr("-1e1")? {
-      Expression::Float(f) => assert_eq!(f, (-1e1 as f64)),
-      _ => assert!(false, "must be a float")
+        Expression::Float(f) => assert_eq!(f, (-1e1 as f64)),
+        _ => assert!(false, "must be a float"),
     };
 
     match parse_expr("-1e-1")? {
-      Expression::Float(f) => assert_eq!(f, (-1e-1 as f64)),
-      _ => assert!(false, "must be a float")
+        Expression::Float(f) => assert_eq!(f, (-1e-1 as f64)),
+        _ => assert!(false, "must be a float"),
     };
 
     match parse_expr("1.0e1")? {
-      Expression::Float(f) => assert_eq!(f, (1.0e1 as f64)),
-      _ => assert!(false, "must be a float")
+        Expression::Float(f) => assert_eq!(f, (1.0e1 as f64)),
+        _ => assert!(false, "must be a float"),
     };
 
     match parse_expr("1e01")? {
-      Expression::Float(f) => assert_eq!(f, (1e01 as f64)),
-      _ => assert!(false, "must be a float")
+        Expression::Float(f) => assert_eq!(f, (1e01 as f64)),
+        _ => assert!(false, "must be a float"),
     };
 
     match parse_expr("1E01")? {
-      Expression::Float(f) => assert_eq!(f, (1e01 as f64)),
-      _ => assert!(false, "must be a float")
+        Expression::Float(f) => assert_eq!(f, (1e01 as f64)),
+        _ => assert!(false, "must be a float"),
     };
 
     Ok(())
-}
\ No newline at end of file
+}
diff --git a/tests/subquery.rs b/tests/subquery.rs
index a5a51a7..41bf54d 100644
--- a/tests/subquery.rs
+++ b/tests/subquery.rs
@@ -6,175 +6,151 @@ use prometheus_parser::*;
 
 #[test]
 fn parse_selector_subquery() -> Result<()> {
-  // not a subquery
-  assert_eq!(
-    parse_expr(r#"foo[5m]"#)?,
-    Selector::new()
-      .metric("foo")
-      .range(PromDuration::Minutes(5))
-      .span((0, 7))
-      .wrap()
-  );
-
-  // invalid whitespace
-  assert_eq!(
-    parse_expr(r#"foo[ 5m:]"#).is_err(),
-    true
-  );
-
-  // valid whitespace
-  assert_eq!(
-    parse_expr(r#"foo[5m  :  30s   ]"#).is_ok(),
-    true
-  );
-
-  assert_eq!(
-    parse_expr(r#"foo[5m:]"#)?,
-    Selector::new()
-      .metric("foo")
-      .subquery(Subquery::new(PromDuration::Minutes(5))
-        .span((3, 8)))
-      .span((0, 8))
-      .wrap()
-  );
-
-  assert_eq!(
-    parse_expr(r#"foo[5m:30s]"#)?,
-    Selector::new()
-      .metric("foo")
-      .subquery(Subquery::new(PromDuration::Minutes(5))
-        .resolution(PromDuration::Seconds(30))
-        .span((3, 11)))
-      .span((0, 11))
-      .wrap()
-  );
-
-  Ok(())
+    // not a subquery
+    assert_eq!(
+        parse_expr(r#"foo[5m]"#)?,
+        Selector::new()
+            .metric("foo")
+            .range(PromDuration::Minutes(5))
+            .span((0, 7))
+            .wrap()
+    );
+
+    // invalid whitespace
+    assert_eq!(parse_expr(r#"foo[ 5m:]"#).is_err(), true);
+
+    // valid whitespace
+    assert_eq!(parse_expr(r#"foo[5m  :  30s   ]"#).is_ok(), true);
+
+    assert_eq!(
+        parse_expr(r#"foo[5m:]"#)?,
+        Selector::new()
+            .metric("foo")
+            .subquery(Subquery::new(PromDuration::Minutes(5)).span((3, 8)))
+            .span((0, 8))
+            .wrap()
+    );
+
+    assert_eq!(
+        parse_expr(r#"foo[5m:30s]"#)?,
+        Selector::new()
+            .metric("foo")
+            .subquery(
+                Subquery::new(PromDuration::Minutes(5))
+                    .resolution(PromDuration::Seconds(30))
+                    .span((3, 11))
+            )
+            .span((0, 11))
+            .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_group_subquery() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"(foo)[5m]"#).is_err(),
-    true
-  );
-
-  assert_eq!(
-    parse_expr(r#"(foo)[5m:]"#)?,
-    Group::new(
-      Selector::new().metric("foo").span((1, 4)).wrap()
-    ).subquery(
-      Subquery::new(PromDuration::Minutes(5)).span((5, 10))
-    ).span((0, 10)).wrap()
-  );
-
-  Ok(())
+    assert_eq!(parse_expr(r#"(foo)[5m]"#).is_err(), true);
+
+    assert_eq!(
+        parse_expr(r#"(foo)[5m:]"#)?,
+        Group::new(Selector::new().metric("foo").span((1, 4)).wrap())
+            .subquery(Subquery::new(PromDuration::Minutes(5)).span((5, 10)))
+            .span((0, 10))
+            .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn parse_function_subquery() -> Result<()> {
-  // not a subquery
-  assert_eq!(
-    parse_expr(r#"sum(foo)[5m]"#).is_err(),
-    true
-  );
-
-  // invalid whitespace
-  assert_eq!(
-    parse_expr(r#"sum(foo)[ 5m:]"#).is_err(),
-    true
-  );
-
-  // valid whitespace
-  assert_eq!(
-    parse_expr(r#"sum(foo)[5m  :  30s   ]"#).is_ok(),
-    true
-  );
-
-  assert_eq!(
-    parse_expr(r#"sum(foo)[5m:]"#)?,
-    Function::new("sum")
-      .arg(Selector::new()
-        .metric("foo")
-        .span((4, 7))
-        .wrap()
-      )
-      .subquery(Subquery::new(PromDuration::Minutes(5)).span((8, 13)))
-      .span((0, 13))
-      .wrap()
-  );
-
-  assert_eq!(
-    parse_expr(r#"sum(foo)[5m:30s]"#)?,
-    Function::new("sum")
-      .arg(Selector::new()
-        .metric("foo")
-        .span((4, 7))
-        .wrap()
-      )
-      .subquery(Subquery::new(PromDuration::Minutes(5))
-        .resolution(PromDuration::Seconds(30))
-        .span((8, 16)))
-      .span((0, 16))
-      .wrap()
-  );
-
-  Ok(())
+    // not a subquery
+    assert_eq!(parse_expr(r#"sum(foo)[5m]"#).is_err(), true);
+
+    // invalid whitespace
+    assert_eq!(parse_expr(r#"sum(foo)[ 5m:]"#).is_err(), true);
+
+    // valid whitespace
+    assert_eq!(parse_expr(r#"sum(foo)[5m  :  30s   ]"#).is_ok(), true);
+
+    assert_eq!(
+        parse_expr(r#"sum(foo)[5m:]"#)?,
+        Function::new("sum")
+            .arg(Selector::new().metric("foo").span((4, 7)).wrap())
+            .subquery(Subquery::new(PromDuration::Minutes(5)).span((8, 13)))
+            .span((0, 13))
+            .wrap()
+    );
+
+    assert_eq!(
+        parse_expr(r#"sum(foo)[5m:30s]"#)?,
+        Function::new("sum")
+            .arg(Selector::new().metric("foo").span((4, 7)).wrap())
+            .subquery(
+                Subquery::new(PromDuration::Minutes(5))
+                    .resolution(PromDuration::Seconds(30))
+                    .span((8, 16))
+            )
+            .span((0, 16))
+            .wrap()
+    );
+
+    Ok(())
 }
 
 #[test]
 fn return_value_subquery() -> Result<()> {
-  assert_eq!(
-    parse_expr(r#"(foo)"#)?.return_value(),
-    ReturnValue {
-      kind: ReturnKind::InstantVector,
-      label_ops: vec![]
-    }
-  );
-
-  assert_eq!(
-    parse_expr(r#"(foo)[5m:30s]"#)?.return_value(),
-    ReturnValue {
-      kind: ReturnKind::RangeVector,
-      label_ops: vec![]
-    }
-  );
-
-  // subquery on a range vector isn't allowed
-  assert_eq!(
-    parse_expr(r#"(foo[5m])[5m:30s]"#)?.return_value(),
-    ReturnValue {
-      kind: ReturnKind::unknown(
-        "subquery on inner expression returning RangeVector is invalid",
-        parse_expr(r#"(foo[5m])[5m:30s]"#)?
-      ),
-      label_ops: vec![]
-    }
-  );
-
-  let expr = parse_expr(r#"sum(foo)"#)?;
-  assert_eq!(
-    expr.return_value(),
-    ReturnValue {
-      kind: ReturnKind::InstantVector,
-      label_ops: vec![LabelSetOp::clear(expr.clone(), Some(Span {
-        start: 0,
-        end: 8
-      }))]
-    }
-  );
-
-  let expr = parse_expr(r#"sum(foo)[5m:]"#)?;
-  assert_eq!(
-    expr.return_value(),
-    ReturnValue {
-      kind: ReturnKind::RangeVector,
-      label_ops: vec![LabelSetOp::clear(expr.clone(), Some(Span {
-        start: 0,
-        end: 13
-      }))]
-    }
-  );
-
-  Ok(())
+    assert_eq!(
+        parse_expr(r#"(foo)"#)?.return_value(),
+        ReturnValue {
+            kind: ReturnKind::InstantVector,
+            label_ops: vec![]
+        }
+    );
+
+    assert_eq!(
+        parse_expr(r#"(foo)[5m:30s]"#)?.return_value(),
+        ReturnValue {
+            kind: ReturnKind::RangeVector,
+            label_ops: vec![]
+        }
+    );
+
+    // subquery on a range vector isn't allowed
+    assert_eq!(
+        parse_expr(r#"(foo[5m])[5m:30s]"#)?.return_value(),
+        ReturnValue {
+            kind: ReturnKind::unknown(
+                "subquery on inner expression returning RangeVector is invalid",
+                parse_expr(r#"(foo[5m])[5m:30s]"#)?
+            ),
+            label_ops: vec![]
+        }
+    );
+
+    let expr = parse_expr(r#"sum(foo)"#)?;
+    assert_eq!(
+        expr.return_value(),
+        ReturnValue {
+            kind: ReturnKind::InstantVector,
+            label_ops: vec![LabelSetOp::clear(
+                expr.clone(),
+                Some(Span { start: 0, end: 8 })
+            )]
+        }
+    );
+
+    let expr = parse_expr(r#"sum(foo)[5m:]"#)?;
+    assert_eq!(
+        expr.return_value(),
+        ReturnValue {
+            kind: ReturnKind::RangeVector,
+            label_ops: vec![LabelSetOp::clear(
+                expr.clone(),
+                Some(Span { start: 0, end: 13 })
+            )]
+        }
+    );
+
+    Ok(())
 }