Struct prometheus_http_query::InstantVector

pub struct InstantVector(pub String);

An instant vector expression that can be further operated on with functions/aggregations or passed to a crate::Client in order to evaluate.

Tuple Fields

0: String

Implementations

impl InstantVector

pub fn add(
    self,
    other: InstantVector,
    match_modifier: Option<Match<'_>>,
    group_modifier: Option<Group<'_>>
) -> Self

Add one instant vector to another. Additional modifiers (Match and Group) can be used to alter the matching behaviour between two instant vectors. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Match, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.add(two, Some(Match::On(&["some_label"])), None);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} + on (some_label) {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn subtract(
    self,
    other: InstantVector,
    match_modifier: Option<Match<'_>>,
    group_modifier: Option<Group<'_>>
) -> Self

Subtract one instant vector from another. Additional modifiers (Match and Group) can be used to alter the matching behaviour between two instant vectors. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Match, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
     let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.subtract(two, Some(Match::Ignoring(&["other_label"])), None);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} - ignoring (other_label) {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn multiply(
    self,
    other: InstantVector,
    match_modifier: Option<Match<'_>>,
    group_modifier: Option<Group<'_>>
) -> Self

Multiply one instant vector by another. Additional modifiers (Match and Group) can be used to alter the matching behaviour between two instant vectors. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Match, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.multiply(two, Some(Match::On(&["some_label"])), None);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} * on (some_label) {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn divide(
    self,
    other: InstantVector,
    match_modifier: Option<Match<'_>>,
    group_modifier: Option<Group<'_>>
) -> Self

Divide one instant vector by another. Additional modifiers (Match and Group) can be used to alter the matching behaviour between two instant vectors. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Match, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.divide(two, Some(Match::Ignoring(&["other_label"])), None);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} / ignoring (other_label) {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn modulo(
    self,
    other: InstantVector,
    match_modifier: Option<Match<'_>>,
    group_modifier: Option<Group<'_>>
) -> Self

Divide one instant vector by another with remainder. Additional modifiers (Match and Group) can be used to alter the matching behaviour between two instant vectors. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Match, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.modulo(two, Some(Match::Ignoring(&["other_label"])), None);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} % ignoring (other_label) {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn power(
    self,
    other: InstantVector,
    match_modifier: Option<Match<'_>>,
    group_modifier: Option<Group<'_>>
) -> Self

Exponentiate one instant vector by another. Additional modifiers (Match and Group) can be used to alter the matching behaviour between two instant vectors. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Match, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.power(two, Some(Match::Ignoring(&["other_label"])), None);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} ^ ignoring (other_label) {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected);

    Ok(())
}

pub fn and(self, other: InstantVector) -> Self

Intersect two vectors so that the result vector consists of all elements of vector1 for which there are matching elements in vector2. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.and(two);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} and {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn or(self, other: InstantVector) -> Self

Combine two vectors so that the result vector consists of all elements of vector1 and also all elements of vector2 which do not have matching label sets in vector1. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.or(two);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} or {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn unless(self, other: InstantVector) -> Self

Combine two vectors so that the result vector consists only of those elements of vector1 for which there are no matching elements in vector2. See the Prometheus reference for details on this topic.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.unless(two);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} unless {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn eq_vector(self, other: InstantVector, return_bool: bool) -> Self

Apply the == operator to two vectors. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.eq_vector(two, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} == {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn ne_vector(self, other: InstantVector, return_bool: bool) -> Self

Apply the != operator to two vectors. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.ne_vector(two, true);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} != bool {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn gt_vector(self, other: InstantVector, return_bool: bool) -> Self

Apply the > operator to two vectors. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.gt_vector(two, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} > {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn lt_vector(self, other: InstantVector, return_bool: bool) -> Self

Apply the < operator to two vectors. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.lt_vector(two, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} < {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn ge_vector(self, other: InstantVector, return_bool: bool) -> Self

Apply the >= operator to two vectors. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.ge_vector(two, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} >= {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn le_vector(self, other: InstantVector, return_bool: bool) -> Self

Apply the <= operator to two vectors. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let two: InstantVector = Selector::new()
        .metric("other_metric")
        .with("some_label", "some_value")
        .with("other_label", "other_value")
        .try_into()?;

    let new = one.le_vector(two, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} <= {__name__="other_metric",some_label="some_value",other_label="other_value"}"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn eq_scalar(self, scalar: f64, return_bool: bool) -> Self

Apply the == operator to a vector and a scalar. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let new = one.eq_scalar(8.5, true);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} == bool 8.5"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn ne_scalar(self, scalar: f64, return_bool: bool) -> Self

Apply the != operator to a vector and a scalar. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let new = one.ne_scalar(8.5, true);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} != bool 8.5"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn gt_scalar(self, scalar: f64, return_bool: bool) -> Self

Apply the > operator to a vector and a scalar. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let new = one.gt_scalar(8.5, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} > 8.5"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn lt_scalar(self, scalar: f64, return_bool: bool) -> Self

Apply the < operator to a vector and a scalar. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let new = one.lt_scalar(8.5, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} < 8.5"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn ge_scalar(self, scalar: f64, return_bool: bool) -> Self

Apply the >= operator to a vector and a scalar. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let new = one.ge_scalar(8.5, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} >= 8.5"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

pub fn le_scalar(self, scalar: f64, return_bool: bool) -> Self

Apply the <= operator to a vector and a scalar. Optionally set the bool parameter to modify the query result as per the PromQL documentation. See the Prometheus reference for details on comparison binary operators.

use prometheus_http_query::Selector;
use prometheus_http_query::InstantVector;
use std::convert::TryInto;

fn main() -> Result<(), prometheus_http_query::Error> {
    let one: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let new = one.le_scalar(8.5, false);

    // This would ultimately be the query string posted to the HTTP API.
    let expected = r#"{__name__="some_metric",some_label="some_value"} <= 8.5"#;

    assert_eq!(new.to_string(), expected.to_string());

    Ok(())
}

Trait Implementations

impl Add<f64> for InstantVector

fn add(self, scalar: f64) -> Self

Add a scalar value to every data sample in a vector.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let v: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let v = v + 4.0;

    assert_eq!(v.to_string(), String::from("{__name__=\"some_metric\",some_label=\"some_value\"} + 4"));

    Ok(())
}

type Output = Self

The resulting type after applying the + operator.

impl BitXor<f64> for InstantVector

fn bitxor(self, scalar: f64) -> Self

Exponentiate each data sample in a vector by a scalar value.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let v: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let v = v ^ 2.0;

    assert_eq!(v.to_string(), String::from("{__name__=\"some_metric\",some_label=\"some_value\"} ^ 2"));

    Ok(())
}

type Output = Self

The resulting type after applying the ^ operator.

impl Debug for InstantVector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for InstantVector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<f64> for InstantVector

fn div(self, scalar: f64) -> Self

Divide each data sample in a vector by a scalar value.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let v: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let v = v / 2.0;

    assert_eq!(v.to_string(), String::from("{__name__=\"some_metric\",some_label=\"some_value\"} / 2"));

    Ok(())
}

type Output = Self

The resulting type after applying the / operator.

impl Mul<f64> for InstantVector

fn mul(self, scalar: f64) -> Self

Multiply each data sample in a vector by a scalar value.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let v: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let v = v * 2.0;

    assert_eq!(v.to_string(), String::from("{__name__=\"some_metric\",some_label=\"some_value\"} * 2"));

    Ok(())
}

type Output = Self

The resulting type after applying the * operator.

impl PartialEq<InstantVector> for InstantVector

fn eq(&self, other: &InstantVector) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &InstantVector) -> bool

This method tests for !=.

impl Rem<f64> for InstantVector

fn rem(self, scalar: f64) -> Self

Divide each data sample in a vector by a scalar value with remainder.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let v: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let v = v % 2.0;

    assert_eq!(v.to_string(), String::from("{__name__=\"some_metric\",some_label=\"some_value\"} % 2"));

    Ok(())
}

type Output = Self

The resulting type after applying the % operator.

impl Sub<f64> for InstantVector

fn sub(self, scalar: f64) -> Self

Subtract a scalar value from every data sample in a vector.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let v: InstantVector = Selector::new()
        .metric("some_metric")
        .with("some_label", "some_value")
        .try_into()?;

    let v = v - 4.5;

    assert_eq!(v.to_string(), String::from("{__name__=\"some_metric\",some_label=\"some_value\"} - 4.5"));

    Ok(())
}

type Output = Self

The resulting type after applying the - operator.

impl TryFrom<Selector<'_>> for InstantVector

fn try_from(selector: Selector<'_>) -> Result<Self, Self::Error>

Convert a Selector to an InstantVector.

use prometheus_http_query::{Selector, InstantVector, Error};
use std::convert::TryInto;

fn main() -> Result<(), Error> {
    let v: Result<InstantVector, Error> = Selector::new()
        .metric("some_metric")
        .try_into();

    assert!(v.is_ok());

    Ok(())
}

type Error = Error

The type returned in the event of a conversion error.

impl StructuralPartialEq for InstantVector