Struct hcl::expr::ForExpr

pub struct ForExpr {
    pub key_var: Option<Identifier>,
    pub value_var: Identifier,
    pub collection_expr: Expression,
    pub key_expr: Option<Expression>,
    pub value_expr: Expression,
    pub grouping: bool,
    pub cond_expr: Option<Expression>,
}

A for expression is a construct for constructing a collection by projecting the items from another collection.

Fields

key_var: Option<Identifier>

Optional name of the variable that will be temporarily assigned the key of each element during iteration. If the source collection is an array, it gets assigned the zero-based array index. For an object source collection, this gets assigned the object’s key.

value_var: Identifier

The name of the variable that will be temporarily assigned the value of each element during iteration.

collection_expr: Expression

An expression that must evaluate to a value that can be iterated.

key_expr: Option<Expression>

An expression that is evaluated once for each key in the source collection. If set, the result of the for expression will be an object. Otherwise, the result will be an array.

value_expr: Expression

An expression that is evaluated once for each value in the source collection.

grouping: bool

Indicates whether grouping mode is enabled. In grouping mode, each value in the resulting object is a list of all of the values that were produced against each distinct key. This is ignored if key_expr is None.

cond_expr: Option<Expression>

An optional filter expression. Elements for which the condition evaluates to true will be evaluated as normal, while if false the element will be skipped.

Implementations

impl ForExpr

pub fn new<C, V>(
    value_var: Identifier,
    collection_expr: C,
    value_expr: V
) -> ForExprwhere
    C: Into<Expression>,
    V: Into<Expression>,

Create a new ForExpr with the name of the variable that will be temporarily assigned the value of each element during iteration, an expression that must evaluate to a value that can be iterated, and one expression that is evaluated once for each value in the source collection.

pub fn with_key_var(self, key_var: Identifier) -> ForExpr

Adds the iterator key variable identifier to the for expression and returns the modified ForExpr.

pub fn with_key_expr<T>(self, key_expr: T) -> ForExprwhere
    T: Into<Expression>,

Adds an expression that is evaluated once for each key in the source collection. If set, the result of the for expression will be an object. Returns the modified ForExpr.

pub fn with_cond_expr<T>(self, cond_expr: T) -> ForExprwhere
    T: Into<Expression>,

Sets the filter expression. Elements for which the condition evaluates to true will be evaluated as normal, while if false the element will be skipped.

pub fn with_grouping(self, yes: bool) -> ForExpr

Enables or disabled grouping mode.

Trait Implementations

impl Clone for ForExpr

fn clone(&self) -> ForExpr

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ForExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ForExpr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Evaluate for ForExpr

type Output = Value

The type that is returned by evaluate on success.

fn evaluate(&self, ctx: &Context<'_>) -> EvalResult<Self::Output>

Recursively evaluates all HCL templates and expressions in the implementing type using the variables and functions declared in the Context.

impl Format for ForExpr

fn format<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<()>where
    W: Write,

Formats a HCL structure using a formatter and writes the result to the provided writer.

fn format_vec<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<Vec<u8>>where
    W: Write + AsMut<Vec<u8>>,

Formats a HCL structure using a formatter and returns the result as a Vec<u8>.

fn format_string<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<String>where
    W: Write + AsMut<Vec<u8>>,

Formats a HCL structure using a formatter and returns the result as a String.

impl From<ForExpr> for Expression

fn from(expr: ForExpr) -> Self

Converts to this type from the input type.

impl<'de> IntoDeserializer<'de, Error> for ForExpr

type Deserializer = MapAccessDeserializer<ForExprAccess>

The type of the deserializer being converted into.

fn into_deserializer(self) -> Self::Deserializer

Convert this value into a deserializer.

impl PartialEq<ForExpr> for ForExpr

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ForExpr

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ForExpr

impl StructuralEq for ForExpr

impl StructuralPartialEq for ForExpr